code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
/*
* 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_OBJECTDET_MODEL_DETECTOBJECTRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectObjectResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string type;
std::vector<double> boxes;
};
int height;
std::vector<Element> elements;
int width;
};
DetectObjectResult();
explicit DetectObjectResult(const std::string &payload);
~DetectObjectResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectObjectResult.h
|
C++
|
apache-2.0
| 1,582
|
/*
* 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_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectTransparentImageRequest : public RpcServiceRequest
{
public:
DetectTransparentImageRequest();
~DetectTransparentImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectTransparentImageRequest.h
|
C++
|
apache-2.0
| 1,394
|
/*
* 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_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGERESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectTransparentImageResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
int transparentImage;
};
std::vector<Element> elements;
};
DetectTransparentImageResult();
explicit DetectTransparentImageResult(const std::string &payload);
~DetectTransparentImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectTransparentImageResult.h
|
C++
|
apache-2.0
| 1,571
|
/*
* 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_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVehicleRequest : public RpcServiceRequest
{
public:
DetectVehicleRequest();
~DetectVehicleRequest();
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_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectVehicleRequest.h
|
C++
|
apache-2.0
| 1,430
|
/*
* 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_OBJECTDET_MODEL_DETECTVEHICLERESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVehicleResult : public ServiceResult
{
public:
struct Data
{
struct DetectObjectInfo
{
float score;
std::string type;
int id;
std::vector<std::string> boxes;
};
std::vector<DetectObjectInfo> detectObjectInfoList;
int height;
int width;
};
DetectVehicleResult();
explicit DetectVehicleResult(const std::string &payload);
~DetectVehicleResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectVehicleResult.h
|
C++
|
apache-2.0
| 1,638
|
/*
* 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_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectWhiteBaseImageRequest : public RpcServiceRequest
{
public:
DetectWhiteBaseImageRequest();
~DetectWhiteBaseImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h
|
C++
|
apache-2.0
| 1,382
|
/*
* 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_OBJECTDET_MODEL_DETECTWHITEBASEIMAGERESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectWhiteBaseImageResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
int whiteBase;
};
std::vector<Element> elements;
};
DetectWhiteBaseImageResult();
explicit DetectWhiteBaseImageResult(const std::string &payload);
~DetectWhiteBaseImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectWhiteBaseImageResult.h
|
C++
|
apache-2.0
| 1,550
|
/*
* 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_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT GenerateVehicleRepairPlanRequest : public RpcServiceRequest
{
public:
struct DamageImageList
{
std::string imageUrl;
std::string createTimeStamp;
};
public:
GenerateVehicleRepairPlanRequest();
~GenerateVehicleRepairPlanRequest();
std::vector<DamageImageList> getDamageImageList()const;
void setDamageImageList(const std::vector<DamageImageList>& damageImageList);
private:
std::vector<DamageImageList> damageImageList_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h
|
C++
|
apache-2.0
| 1,609
|
/*
* 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_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT GenerateVehicleRepairPlanResult : public ServiceResult
{
public:
struct Data
{
std::string taskId;
};
GenerateVehicleRepairPlanResult();
explicit GenerateVehicleRepairPlanResult(const std::string &payload);
~GenerateVehicleRepairPlanResult();
int getHttpCode()const;
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int httpCode_;
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanResult.h
|
C++
|
apache-2.0
| 1,738
|
/*
* 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_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT GetVehicleRepairPlanRequest : public RpcServiceRequest
{
public:
GetVehicleRepairPlanRequest();
~GetVehicleRepairPlanRequest();
std::string getVinCodeImage()const;
void setVinCodeImage(const std::string& vinCodeImage);
std::string getCarNumberImage()const;
void setCarNumberImage(const std::string& carNumberImage);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
private:
std::string vinCodeImage_;
std::string carNumberImage_;
std::string taskId_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/GetVehicleRepairPlanRequest.h
|
C++
|
apache-2.0
| 1,648
|
/*
* 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_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT GetVehicleRepairPlanResult : public ServiceResult
{
public:
struct Data
{
struct RepairItems
{
bool partNameMatch;
std::string partsStdCode;
std::string outStandardPartsName;
std::string repairType;
std::string relationType;
std::string repairFee;
std::string garageType;
std::string partsStdName;
std::string outStandardPartsId;
std::string repairTypeName;
bool oeMatch;
};
std::string frameNo;
std::vector<RepairItems> repairParts;
};
GetVehicleRepairPlanResult();
explicit GetVehicleRepairPlanResult(const std::string &payload);
~GetVehicleRepairPlanResult();
int getHttpCode()const;
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int httpCode_;
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h
|
C++
|
apache-2.0
| 2,129
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDamageRequest : public RpcServiceRequest
{
public:
RecognizeVehicleDamageRequest();
~RecognizeVehicleDamageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h
|
C++
|
apache-2.0
| 1,394
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGERESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDamageResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string type;
std::vector<std::string> scores;
std::vector<std::string> boxes;
};
std::vector<Element> elements;
};
RecognizeVehicleDamageResult();
explicit RecognizeVehicleDamageResult(const std::string &payload);
~RecognizeVehicleDamageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDamageResult.h
|
C++
|
apache-2.0
| 1,663
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDashboardRequest : public RpcServiceRequest
{
public:
RecognizeVehicleDashboardRequest();
~RecognizeVehicleDashboardRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h
|
C++
|
apache-2.0
| 1,412
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDashboardResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string className;
std::string label;
std::vector<std::string> boxes;
};
std::vector<Element> elements;
};
RecognizeVehicleDashboardResult();
explicit RecognizeVehicleDashboardResult(const std::string &payload);
~RecognizeVehicleDashboardResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDashboardResult.h
|
C++
|
apache-2.0
| 1,675
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehiclePartsRequest : public RpcServiceRequest
{
public:
RecognizeVehiclePartsRequest();
~RecognizeVehiclePartsRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h
|
C++
|
apache-2.0
| 1,388
|
/*
* 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_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehiclePartsResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string type;
std::vector<std::string> boxes;
};
std::vector<Element> elements;
std::vector<std::string> originShapes;
};
RecognizeVehiclePartsResult();
explicit RecognizeVehiclePartsResult(const std::string &payload);
~RecognizeVehiclePartsResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/RecognizeVehiclePartsResult.h
|
C++
|
apache-2.0
| 1,661
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/ObjectdetClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
namespace
{
const std::string SERVICE_NAME = "objectdet";
}
ObjectdetClient::ObjectdetClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
}
ObjectdetClient::ObjectdetClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
}
ObjectdetClient::ObjectdetClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
}
ObjectdetClient::~ObjectdetClient()
{}
ObjectdetClient::ClassifyVehicleInsuranceOutcome ObjectdetClient::classifyVehicleInsurance(const ClassifyVehicleInsuranceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ClassifyVehicleInsuranceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ClassifyVehicleInsuranceOutcome(ClassifyVehicleInsuranceResult(outcome.result()));
else
return ClassifyVehicleInsuranceOutcome(outcome.error());
}
void ObjectdetClient::classifyVehicleInsuranceAsync(const ClassifyVehicleInsuranceRequest& request, const ClassifyVehicleInsuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, classifyVehicleInsurance(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::ClassifyVehicleInsuranceOutcomeCallable ObjectdetClient::classifyVehicleInsuranceCallable(const ClassifyVehicleInsuranceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ClassifyVehicleInsuranceOutcome()>>(
[this, request]()
{
return this->classifyVehicleInsurance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::DetectMainBodyOutcome ObjectdetClient::detectMainBody(const DetectMainBodyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectMainBodyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectMainBodyOutcome(DetectMainBodyResult(outcome.result()));
else
return DetectMainBodyOutcome(outcome.error());
}
void ObjectdetClient::detectMainBodyAsync(const DetectMainBodyRequest& request, const DetectMainBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectMainBody(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::DetectMainBodyOutcomeCallable ObjectdetClient::detectMainBodyCallable(const DetectMainBodyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectMainBodyOutcome()>>(
[this, request]()
{
return this->detectMainBody(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::DetectObjectOutcome ObjectdetClient::detectObject(const DetectObjectRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectObjectOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectObjectOutcome(DetectObjectResult(outcome.result()));
else
return DetectObjectOutcome(outcome.error());
}
void ObjectdetClient::detectObjectAsync(const DetectObjectRequest& request, const DetectObjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectObject(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::DetectObjectOutcomeCallable ObjectdetClient::detectObjectCallable(const DetectObjectRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectObjectOutcome()>>(
[this, request]()
{
return this->detectObject(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::DetectTransparentImageOutcome ObjectdetClient::detectTransparentImage(const DetectTransparentImageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectTransparentImageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectTransparentImageOutcome(DetectTransparentImageResult(outcome.result()));
else
return DetectTransparentImageOutcome(outcome.error());
}
void ObjectdetClient::detectTransparentImageAsync(const DetectTransparentImageRequest& request, const DetectTransparentImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectTransparentImage(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::DetectTransparentImageOutcomeCallable ObjectdetClient::detectTransparentImageCallable(const DetectTransparentImageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectTransparentImageOutcome()>>(
[this, request]()
{
return this->detectTransparentImage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::DetectVehicleOutcome ObjectdetClient::detectVehicle(const DetectVehicleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectVehicleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectVehicleOutcome(DetectVehicleResult(outcome.result()));
else
return DetectVehicleOutcome(outcome.error());
}
void ObjectdetClient::detectVehicleAsync(const DetectVehicleRequest& request, const DetectVehicleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectVehicle(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::DetectVehicleOutcomeCallable ObjectdetClient::detectVehicleCallable(const DetectVehicleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectVehicleOutcome()>>(
[this, request]()
{
return this->detectVehicle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::DetectWhiteBaseImageOutcome ObjectdetClient::detectWhiteBaseImage(const DetectWhiteBaseImageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectWhiteBaseImageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectWhiteBaseImageOutcome(DetectWhiteBaseImageResult(outcome.result()));
else
return DetectWhiteBaseImageOutcome(outcome.error());
}
void ObjectdetClient::detectWhiteBaseImageAsync(const DetectWhiteBaseImageRequest& request, const DetectWhiteBaseImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectWhiteBaseImage(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::DetectWhiteBaseImageOutcomeCallable ObjectdetClient::detectWhiteBaseImageCallable(const DetectWhiteBaseImageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectWhiteBaseImageOutcome()>>(
[this, request]()
{
return this->detectWhiteBaseImage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::GenerateVehicleRepairPlanOutcome ObjectdetClient::generateVehicleRepairPlan(const GenerateVehicleRepairPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateVehicleRepairPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateVehicleRepairPlanOutcome(GenerateVehicleRepairPlanResult(outcome.result()));
else
return GenerateVehicleRepairPlanOutcome(outcome.error());
}
void ObjectdetClient::generateVehicleRepairPlanAsync(const GenerateVehicleRepairPlanRequest& request, const GenerateVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateVehicleRepairPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::GenerateVehicleRepairPlanOutcomeCallable ObjectdetClient::generateVehicleRepairPlanCallable(const GenerateVehicleRepairPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateVehicleRepairPlanOutcome()>>(
[this, request]()
{
return this->generateVehicleRepairPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::GetVehicleRepairPlanOutcome ObjectdetClient::getVehicleRepairPlan(const GetVehicleRepairPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVehicleRepairPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVehicleRepairPlanOutcome(GetVehicleRepairPlanResult(outcome.result()));
else
return GetVehicleRepairPlanOutcome(outcome.error());
}
void ObjectdetClient::getVehicleRepairPlanAsync(const GetVehicleRepairPlanRequest& request, const GetVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVehicleRepairPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::GetVehicleRepairPlanOutcomeCallable ObjectdetClient::getVehicleRepairPlanCallable(const GetVehicleRepairPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVehicleRepairPlanOutcome()>>(
[this, request]()
{
return this->getVehicleRepairPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::RecognizeVehicleDamageOutcome ObjectdetClient::recognizeVehicleDamage(const RecognizeVehicleDamageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVehicleDamageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVehicleDamageOutcome(RecognizeVehicleDamageResult(outcome.result()));
else
return RecognizeVehicleDamageOutcome(outcome.error());
}
void ObjectdetClient::recognizeVehicleDamageAsync(const RecognizeVehicleDamageRequest& request, const RecognizeVehicleDamageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVehicleDamage(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::RecognizeVehicleDamageOutcomeCallable ObjectdetClient::recognizeVehicleDamageCallable(const RecognizeVehicleDamageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVehicleDamageOutcome()>>(
[this, request]()
{
return this->recognizeVehicleDamage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::RecognizeVehicleDashboardOutcome ObjectdetClient::recognizeVehicleDashboard(const RecognizeVehicleDashboardRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVehicleDashboardOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVehicleDashboardOutcome(RecognizeVehicleDashboardResult(outcome.result()));
else
return RecognizeVehicleDashboardOutcome(outcome.error());
}
void ObjectdetClient::recognizeVehicleDashboardAsync(const RecognizeVehicleDashboardRequest& request, const RecognizeVehicleDashboardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVehicleDashboard(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::RecognizeVehicleDashboardOutcomeCallable ObjectdetClient::recognizeVehicleDashboardCallable(const RecognizeVehicleDashboardRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVehicleDashboardOutcome()>>(
[this, request]()
{
return this->recognizeVehicleDashboard(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::RecognizeVehiclePartsOutcome ObjectdetClient::recognizeVehicleParts(const RecognizeVehiclePartsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVehiclePartsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVehiclePartsOutcome(RecognizeVehiclePartsResult(outcome.result()));
else
return RecognizeVehiclePartsOutcome(outcome.error());
}
void ObjectdetClient::recognizeVehiclePartsAsync(const RecognizeVehiclePartsRequest& request, const RecognizeVehiclePartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVehicleParts(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::RecognizeVehiclePartsOutcomeCallable ObjectdetClient::recognizeVehiclePartsCallable(const RecognizeVehiclePartsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVehiclePartsOutcome()>>(
[this, request]()
{
return this->recognizeVehicleParts(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/ObjectdetClient.cc
|
C++
|
apache-2.0
| 16,581
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h>
using AlibabaCloud::Objectdet::Model::ClassifyVehicleInsuranceRequest;
ClassifyVehicleInsuranceRequest::ClassifyVehicleInsuranceRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "ClassifyVehicleInsurance")
{
setMethod(HttpRequest::Method::Post);
}
ClassifyVehicleInsuranceRequest::~ClassifyVehicleInsuranceRequest()
{}
std::string ClassifyVehicleInsuranceRequest::getImageURL()const
{
return imageURL_;
}
void ClassifyVehicleInsuranceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/ClassifyVehicleInsuranceRequest.cc
|
C++
|
apache-2.0
| 1,283
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/ClassifyVehicleInsuranceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
ClassifyVehicleInsuranceResult::ClassifyVehicleInsuranceResult() :
ServiceResult()
{}
ClassifyVehicleInsuranceResult::ClassifyVehicleInsuranceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ClassifyVehicleInsuranceResult::~ClassifyVehicleInsuranceResult()
{}
void ClassifyVehicleInsuranceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Threshold"].isNull())
data_.threshold = std::stof(dataNode["Threshold"].asString());
auto allLabelsNode = dataNode["Labels"]["Label"];
for (auto dataNodeLabelsLabel : allLabelsNode)
{
Data::Label labelObject;
if(!dataNodeLabelsLabel["Score"].isNull())
labelObject.score = std::stof(dataNodeLabelsLabel["Score"].asString());
if(!dataNodeLabelsLabel["Name"].isNull())
labelObject.name = dataNodeLabelsLabel["Name"].asString();
data_.labels.push_back(labelObject);
}
}
ClassifyVehicleInsuranceResult::Data ClassifyVehicleInsuranceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/ClassifyVehicleInsuranceResult.cc
|
C++
|
apache-2.0
| 1,936
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectMainBodyRequest.h>
using AlibabaCloud::Objectdet::Model::DetectMainBodyRequest;
DetectMainBodyRequest::DetectMainBodyRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectMainBody")
{
setMethod(HttpRequest::Method::Post);
}
DetectMainBodyRequest::~DetectMainBodyRequest()
{}
std::string DetectMainBodyRequest::getImageURL()const
{
return imageURL_;
}
void DetectMainBodyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectMainBodyRequest.cc
|
C++
|
apache-2.0
| 1,189
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectMainBodyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
DetectMainBodyResult::DetectMainBodyResult() :
ServiceResult()
{}
DetectMainBodyResult::DetectMainBodyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectMainBodyResult::~DetectMainBodyResult()
{}
void DetectMainBodyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto locationNode = dataNode["Location"];
if(!locationNode["X"].isNull())
data_.location.x = std::stoi(locationNode["X"].asString());
if(!locationNode["Y"].isNull())
data_.location.y = std::stoi(locationNode["Y"].asString());
if(!locationNode["Width"].isNull())
data_.location.width = std::stoi(locationNode["Width"].asString());
if(!locationNode["Height"].isNull())
data_.location.height = std::stoi(locationNode["Height"].asString());
}
DetectMainBodyResult::Data DetectMainBodyResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectMainBodyResult.cc
|
C++
|
apache-2.0
| 1,787
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectObjectRequest;
DetectObjectRequest::DetectObjectRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectObject")
{
setMethod(HttpRequest::Method::Post);
}
DetectObjectRequest::~DetectObjectRequest()
{}
std::string DetectObjectRequest::getImageURL()const
{
return imageURL_;
}
void DetectObjectRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectObjectRequest.cc
|
C++
|
apache-2.0
| 1,175
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectObjectResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
DetectObjectResult::DetectObjectResult() :
ServiceResult()
{}
DetectObjectResult::DetectObjectResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectObjectResult::~DetectObjectResult()
{}
void DetectObjectResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Width"].isNull())
data_.width = std::stoi(dataNode["Width"].asString());
if(!dataNode["Height"].isNull())
data_.height = std::stoi(dataNode["Height"].asString());
auto allElementsNode = dataNode["Elements"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Score"].isNull())
elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
if(!dataNodeElementsElement["Type"].isNull())
elementObject.type = dataNodeElementsElement["Type"].asString();
auto allBoxes = dataNodeElementsElement["Boxes"];
for (auto value : allBoxes)
elementObject.boxes.push_back(value.asDouble());
data_.elements.push_back(elementObject);
}
}
DetectObjectResult::Data DetectObjectResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectObjectResult.cc
|
C++
|
apache-2.0
| 2,060
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectTransparentImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectTransparentImageRequest;
DetectTransparentImageRequest::DetectTransparentImageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectTransparentImage")
{
setMethod(HttpRequest::Method::Post);
}
DetectTransparentImageRequest::~DetectTransparentImageRequest()
{}
std::string DetectTransparentImageRequest::getImageURL()const
{
return imageURL_;
}
void DetectTransparentImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectTransparentImageRequest.cc
|
C++
|
apache-2.0
| 1,265
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectTransparentImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
DetectTransparentImageResult::DetectTransparentImageResult() :
ServiceResult()
{}
DetectTransparentImageResult::DetectTransparentImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectTransparentImageResult::~DetectTransparentImageResult()
{}
void DetectTransparentImageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["TransparentImage"].isNull())
elementObject.transparentImage = std::stoi(dataNodeElementsElement["TransparentImage"].asString());
data_.elements.push_back(elementObject);
}
}
DetectTransparentImageResult::Data DetectTransparentImageResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectTransparentImageResult.cc
|
C++
|
apache-2.0
| 1,771
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectVehicleRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleRequest;
DetectVehicleRequest::DetectVehicleRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicle")
{
setMethod(HttpRequest::Method::Post);
}
DetectVehicleRequest::~DetectVehicleRequest()
{}
int DetectVehicleRequest::getImageType()const
{
return imageType_;
}
void DetectVehicleRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string DetectVehicleRequest::getImageURL()const
{
return imageURL_;
}
void DetectVehicleRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectVehicleRequest.cc
|
C++
|
apache-2.0
| 1,410
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectVehicleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
DetectVehicleResult::DetectVehicleResult() :
ServiceResult()
{}
DetectVehicleResult::DetectVehicleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectVehicleResult::~DetectVehicleResult()
{}
void DetectVehicleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Width"].isNull())
data_.width = std::stoi(dataNode["Width"].asString());
if(!dataNode["Height"].isNull())
data_.height = std::stoi(dataNode["Height"].asString());
auto allDetectObjectInfoListNode = dataNode["DetectObjectInfoList"]["DetectObjectInfo"];
for (auto dataNodeDetectObjectInfoListDetectObjectInfo : allDetectObjectInfoListNode)
{
Data::DetectObjectInfo detectObjectInfoObject;
if(!dataNodeDetectObjectInfoListDetectObjectInfo["Score"].isNull())
detectObjectInfoObject.score = std::stof(dataNodeDetectObjectInfoListDetectObjectInfo["Score"].asString());
if(!dataNodeDetectObjectInfoListDetectObjectInfo["Type"].isNull())
detectObjectInfoObject.type = dataNodeDetectObjectInfoListDetectObjectInfo["Type"].asString();
if(!dataNodeDetectObjectInfoListDetectObjectInfo["Id"].isNull())
detectObjectInfoObject.id = std::stoi(dataNodeDetectObjectInfoListDetectObjectInfo["Id"].asString());
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
detectObjectInfoObject.boxes.push_back(value.asString());
data_.detectObjectInfoList.push_back(detectObjectInfoObject);
}
}
DetectVehicleResult::Data DetectVehicleResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectVehicleResult.cc
|
C++
|
apache-2.0
| 2,458
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectWhiteBaseImageRequest;
DetectWhiteBaseImageRequest::DetectWhiteBaseImageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectWhiteBaseImage")
{
setMethod(HttpRequest::Method::Post);
}
DetectWhiteBaseImageRequest::~DetectWhiteBaseImageRequest()
{}
std::string DetectWhiteBaseImageRequest::getImageURL()const
{
return imageURL_;
}
void DetectWhiteBaseImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectWhiteBaseImageRequest.cc
|
C++
|
apache-2.0
| 1,247
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectWhiteBaseImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
DetectWhiteBaseImageResult::DetectWhiteBaseImageResult() :
ServiceResult()
{}
DetectWhiteBaseImageResult::DetectWhiteBaseImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectWhiteBaseImageResult::~DetectWhiteBaseImageResult()
{}
void DetectWhiteBaseImageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["WhiteBase"].isNull())
elementObject.whiteBase = std::stoi(dataNodeElementsElement["WhiteBase"].asString());
data_.elements.push_back(elementObject);
}
}
DetectWhiteBaseImageResult::Data DetectWhiteBaseImageResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/DetectWhiteBaseImageResult.cc
|
C++
|
apache-2.0
| 1,730
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h>
using AlibabaCloud::Objectdet::Model::GenerateVehicleRepairPlanRequest;
GenerateVehicleRepairPlanRequest::GenerateVehicleRepairPlanRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "GenerateVehicleRepairPlan")
{
setMethod(HttpRequest::Method::Post);
}
GenerateVehicleRepairPlanRequest::~GenerateVehicleRepairPlanRequest()
{}
std::vector<GenerateVehicleRepairPlanRequest::DamageImageList> GenerateVehicleRepairPlanRequest::getDamageImageList()const
{
return damageImageList_;
}
void GenerateVehicleRepairPlanRequest::setDamageImageList(const std::vector<DamageImageList>& damageImageList)
{
damageImageList_ = damageImageList;
for(int dep1 = 0; dep1!= damageImageList.size(); dep1++) {
auto damageImageListObj = damageImageList.at(dep1);
std::string damageImageListObjStr = "DamageImageList." + std::to_string(dep1 + 1);
setParameter(damageImageListObjStr + ".ImageUrl", damageImageListObj.imageUrl);
setParameter(damageImageListObjStr + ".CreateTimeStamp", damageImageListObj.createTimeStamp);
}
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/GenerateVehicleRepairPlanRequest.cc
|
C++
|
apache-2.0
| 1,745
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/GenerateVehicleRepairPlanResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
GenerateVehicleRepairPlanResult::GenerateVehicleRepairPlanResult() :
ServiceResult()
{}
GenerateVehicleRepairPlanResult::GenerateVehicleRepairPlanResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenerateVehicleRepairPlanResult::~GenerateVehicleRepairPlanResult()
{}
void GenerateVehicleRepairPlanResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["TaskId"].isNull())
data_.taskId = dataNode["TaskId"].asString();
if(!value["HttpCode"].isNull())
httpCode_ = std::stoi(value["HttpCode"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["ErrorMessage"].isNull())
errorMessage_ = value["ErrorMessage"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
int GenerateVehicleRepairPlanResult::getHttpCode()const
{
return httpCode_;
}
GenerateVehicleRepairPlanResult::Data GenerateVehicleRepairPlanResult::getData()const
{
return data_;
}
std::string GenerateVehicleRepairPlanResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GenerateVehicleRepairPlanResult::getCode()const
{
return code_;
}
bool GenerateVehicleRepairPlanResult::getSuccess()const
{
return success_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/GenerateVehicleRepairPlanResult.cc
|
C++
|
apache-2.0
| 2,190
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/GetVehicleRepairPlanRequest.h>
using AlibabaCloud::Objectdet::Model::GetVehicleRepairPlanRequest;
GetVehicleRepairPlanRequest::GetVehicleRepairPlanRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "GetVehicleRepairPlan")
{
setMethod(HttpRequest::Method::Post);
}
GetVehicleRepairPlanRequest::~GetVehicleRepairPlanRequest()
{}
std::string GetVehicleRepairPlanRequest::getVinCodeImage()const
{
return vinCodeImage_;
}
void GetVehicleRepairPlanRequest::setVinCodeImage(const std::string& vinCodeImage)
{
vinCodeImage_ = vinCodeImage;
setBodyParameter("VinCodeImage", vinCodeImage);
}
std::string GetVehicleRepairPlanRequest::getCarNumberImage()const
{
return carNumberImage_;
}
void GetVehicleRepairPlanRequest::setCarNumberImage(const std::string& carNumberImage)
{
carNumberImage_ = carNumberImage;
setBodyParameter("CarNumberImage", carNumberImage);
}
std::string GetVehicleRepairPlanRequest::getTaskId()const
{
return taskId_;
}
void GetVehicleRepairPlanRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/GetVehicleRepairPlanRequest.cc
|
C++
|
apache-2.0
| 1,789
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
GetVehicleRepairPlanResult::GetVehicleRepairPlanResult() :
ServiceResult()
{}
GetVehicleRepairPlanResult::GetVehicleRepairPlanResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVehicleRepairPlanResult::~GetVehicleRepairPlanResult()
{}
void GetVehicleRepairPlanResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["FrameNo"].isNull())
data_.frameNo = dataNode["FrameNo"].asString();
auto allRepairPartsNode = dataNode["RepairParts"]["RepairItems"];
for (auto dataNodeRepairPartsRepairItems : allRepairPartsNode)
{
Data::RepairItems repairItemsObject;
if(!dataNodeRepairPartsRepairItems["GarageType"].isNull())
repairItemsObject.garageType = dataNodeRepairPartsRepairItems["GarageType"].asString();
if(!dataNodeRepairPartsRepairItems["OeMatch"].isNull())
repairItemsObject.oeMatch = dataNodeRepairPartsRepairItems["OeMatch"].asString() == "true";
if(!dataNodeRepairPartsRepairItems["OutStandardPartsId"].isNull())
repairItemsObject.outStandardPartsId = dataNodeRepairPartsRepairItems["OutStandardPartsId"].asString();
if(!dataNodeRepairPartsRepairItems["OutStandardPartsName"].isNull())
repairItemsObject.outStandardPartsName = dataNodeRepairPartsRepairItems["OutStandardPartsName"].asString();
if(!dataNodeRepairPartsRepairItems["PartNameMatch"].isNull())
repairItemsObject.partNameMatch = dataNodeRepairPartsRepairItems["PartNameMatch"].asString() == "true";
if(!dataNodeRepairPartsRepairItems["PartsStdCode"].isNull())
repairItemsObject.partsStdCode = dataNodeRepairPartsRepairItems["PartsStdCode"].asString();
if(!dataNodeRepairPartsRepairItems["PartsStdName"].isNull())
repairItemsObject.partsStdName = dataNodeRepairPartsRepairItems["PartsStdName"].asString();
if(!dataNodeRepairPartsRepairItems["RelationType"].isNull())
repairItemsObject.relationType = dataNodeRepairPartsRepairItems["RelationType"].asString();
if(!dataNodeRepairPartsRepairItems["RepairFee"].isNull())
repairItemsObject.repairFee = dataNodeRepairPartsRepairItems["RepairFee"].asString();
if(!dataNodeRepairPartsRepairItems["RepairType"].isNull())
repairItemsObject.repairType = dataNodeRepairPartsRepairItems["RepairType"].asString();
if(!dataNodeRepairPartsRepairItems["RepairTypeName"].isNull())
repairItemsObject.repairTypeName = dataNodeRepairPartsRepairItems["RepairTypeName"].asString();
data_.repairParts.push_back(repairItemsObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["ErrorMessage"].isNull())
errorMessage_ = value["ErrorMessage"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["HttpCode"].isNull())
httpCode_ = std::stoi(value["HttpCode"].asString());
}
int GetVehicleRepairPlanResult::getHttpCode()const
{
return httpCode_;
}
GetVehicleRepairPlanResult::Data GetVehicleRepairPlanResult::getData()const
{
return data_;
}
std::string GetVehicleRepairPlanResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GetVehicleRepairPlanResult::getCode()const
{
return code_;
}
bool GetVehicleRepairPlanResult::getSuccess()const
{
return success_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/GetVehicleRepairPlanResult.cc
|
C++
|
apache-2.0
| 4,122
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDamageRequest;
RecognizeVehicleDamageRequest::RecognizeVehicleDamageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDamage")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehicleDamageRequest::~RecognizeVehicleDamageRequest()
{}
std::string RecognizeVehicleDamageRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeVehicleDamageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehicleDamageRequest.cc
|
C++
|
apache-2.0
| 1,265
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDamageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
RecognizeVehicleDamageResult::RecognizeVehicleDamageResult() :
ServiceResult()
{}
RecognizeVehicleDamageResult::RecognizeVehicleDamageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeVehicleDamageResult::~RecognizeVehicleDamageResult()
{}
void RecognizeVehicleDamageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Score"].isNull())
elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
if(!dataNodeElementsElement["Type"].isNull())
elementObject.type = dataNodeElementsElement["Type"].asString();
auto allScores = value["Scores"]["Score"];
for (auto value : allScores)
elementObject.scores.push_back(value.asString());
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
elementObject.boxes.push_back(value.asString());
data_.elements.push_back(elementObject);
}
}
RecognizeVehicleDamageResult::Data RecognizeVehicleDamageResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehicleDamageResult.cc
|
C++
|
apache-2.0
| 2,106
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDashboardRequest;
RecognizeVehicleDashboardRequest::RecognizeVehicleDashboardRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDashboard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehicleDashboardRequest::~RecognizeVehicleDashboardRequest()
{}
std::string RecognizeVehicleDashboardRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeVehicleDashboardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehicleDashboardRequest.cc
|
C++
|
apache-2.0
| 1,292
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDashboardResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
RecognizeVehicleDashboardResult::RecognizeVehicleDashboardResult() :
ServiceResult()
{}
RecognizeVehicleDashboardResult::RecognizeVehicleDashboardResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeVehicleDashboardResult::~RecognizeVehicleDashboardResult()
{}
void RecognizeVehicleDashboardResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Score"].isNull())
elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
if(!dataNodeElementsElement["ClassName"].isNull())
elementObject.className = dataNodeElementsElement["ClassName"].asString();
if(!dataNodeElementsElement["Label"].isNull())
elementObject.label = dataNodeElementsElement["Label"].asString();
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
elementObject.boxes.push_back(value.asString());
data_.elements.push_back(elementObject);
}
}
RecognizeVehicleDashboardResult::Data RecognizeVehicleDashboardResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehicleDashboardResult.cc
|
C++
|
apache-2.0
| 2,141
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehiclePartsRequest;
RecognizeVehiclePartsRequest::RecognizeVehiclePartsRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleParts")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehiclePartsRequest::~RecognizeVehiclePartsRequest()
{}
std::string RecognizeVehiclePartsRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeVehiclePartsRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehiclePartsRequest.cc
|
C++
|
apache-2.0
| 1,256
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/RecognizeVehiclePartsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
RecognizeVehiclePartsResult::RecognizeVehiclePartsResult() :
ServiceResult()
{}
RecognizeVehiclePartsResult::RecognizeVehiclePartsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeVehiclePartsResult::~RecognizeVehiclePartsResult()
{}
void RecognizeVehiclePartsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Score"].isNull())
elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
if(!dataNodeElementsElement["Type"].isNull())
elementObject.type = dataNodeElementsElement["Type"].asString();
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
elementObject.boxes.push_back(value.asString());
data_.elements.push_back(elementObject);
}
auto allOriginShapes = dataNode["OriginShapes"]["OriginShape"];
for (auto value : allOriginShapes)
data_.originShapes.push_back(value.asString());
}
RecognizeVehiclePartsResult::Data RecognizeVehiclePartsResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/src/model/RecognizeVehiclePartsResult.cc
|
C++
|
apache-2.0
| 2,121
|
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(ocr_public_header
include/alibabacloud/ocr/OcrClient.h
include/alibabacloud/ocr/OcrExport.h )
set(ocr_public_header_model
include/alibabacloud/ocr/model/DetectCardScreenshotRequest.h
include/alibabacloud/ocr/model/DetectCardScreenshotResult.h
include/alibabacloud/ocr/model/GetAsyncJobResultRequest.h
include/alibabacloud/ocr/model/GetAsyncJobResultResult.h
include/alibabacloud/ocr/model/RecognizeAccountPageRequest.h
include/alibabacloud/ocr/model/RecognizeAccountPageResult.h
include/alibabacloud/ocr/model/RecognizeBankCardRequest.h
include/alibabacloud/ocr/model/RecognizeBankCardResult.h
include/alibabacloud/ocr/model/RecognizeBusinessCardRequest.h
include/alibabacloud/ocr/model/RecognizeBusinessCardResult.h
include/alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h
include/alibabacloud/ocr/model/RecognizeBusinessLicenseResult.h
include/alibabacloud/ocr/model/RecognizeCharacterRequest.h
include/alibabacloud/ocr/model/RecognizeCharacterResult.h
include/alibabacloud/ocr/model/RecognizeChinapassportRequest.h
include/alibabacloud/ocr/model/RecognizeChinapassportResult.h
include/alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h
include/alibabacloud/ocr/model/RecognizeDriverLicenseResult.h
include/alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h
include/alibabacloud/ocr/model/RecognizeDrivingLicenseResult.h
include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h
include/alibabacloud/ocr/model/RecognizeIdentityCardResult.h
include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
include/alibabacloud/ocr/model/RecognizeLicensePlateResult.h
include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
include/alibabacloud/ocr/model/RecognizePassportMRZResult.h
include/alibabacloud/ocr/model/RecognizePoiNameRequest.h
include/alibabacloud/ocr/model/RecognizePoiNameResult.h
include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h
include/alibabacloud/ocr/model/RecognizeQrCodeResult.h
include/alibabacloud/ocr/model/RecognizeStampRequest.h
include/alibabacloud/ocr/model/RecognizeStampResult.h
include/alibabacloud/ocr/model/RecognizeTableRequest.h
include/alibabacloud/ocr/model/RecognizeTableResult.h
include/alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h
include/alibabacloud/ocr/model/RecognizeTakeoutOrderResult.h
include/alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h
include/alibabacloud/ocr/model/RecognizeTaxiInvoiceResult.h
include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
include/alibabacloud/ocr/model/RecognizeVATInvoiceResult.h
include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
include/alibabacloud/ocr/model/RecognizeVINCodeResult.h
include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h
include/alibabacloud/ocr/model/RecognizeVerificationcodeResult.h
include/alibabacloud/ocr/model/TrimDocumentRequest.h
include/alibabacloud/ocr/model/TrimDocumentResult.h )
set(ocr_src
src/OcrClient.cc
src/model/DetectCardScreenshotRequest.cc
src/model/DetectCardScreenshotResult.cc
src/model/GetAsyncJobResultRequest.cc
src/model/GetAsyncJobResultResult.cc
src/model/RecognizeAccountPageRequest.cc
src/model/RecognizeAccountPageResult.cc
src/model/RecognizeBankCardRequest.cc
src/model/RecognizeBankCardResult.cc
src/model/RecognizeBusinessCardRequest.cc
src/model/RecognizeBusinessCardResult.cc
src/model/RecognizeBusinessLicenseRequest.cc
src/model/RecognizeBusinessLicenseResult.cc
src/model/RecognizeCharacterRequest.cc
src/model/RecognizeCharacterResult.cc
src/model/RecognizeChinapassportRequest.cc
src/model/RecognizeChinapassportResult.cc
src/model/RecognizeDriverLicenseRequest.cc
src/model/RecognizeDriverLicenseResult.cc
src/model/RecognizeDrivingLicenseRequest.cc
src/model/RecognizeDrivingLicenseResult.cc
src/model/RecognizeIdentityCardRequest.cc
src/model/RecognizeIdentityCardResult.cc
src/model/RecognizeLicensePlateRequest.cc
src/model/RecognizeLicensePlateResult.cc
src/model/RecognizePassportMRZRequest.cc
src/model/RecognizePassportMRZResult.cc
src/model/RecognizePoiNameRequest.cc
src/model/RecognizePoiNameResult.cc
src/model/RecognizeQrCodeRequest.cc
src/model/RecognizeQrCodeResult.cc
src/model/RecognizeStampRequest.cc
src/model/RecognizeStampResult.cc
src/model/RecognizeTableRequest.cc
src/model/RecognizeTableResult.cc
src/model/RecognizeTakeoutOrderRequest.cc
src/model/RecognizeTakeoutOrderResult.cc
src/model/RecognizeTaxiInvoiceRequest.cc
src/model/RecognizeTaxiInvoiceResult.cc
src/model/RecognizeTrainTicketRequest.cc
src/model/RecognizeTrainTicketResult.cc
src/model/RecognizeVATInvoiceRequest.cc
src/model/RecognizeVATInvoiceResult.cc
src/model/RecognizeVINCodeRequest.cc
src/model/RecognizeVINCodeResult.cc
src/model/RecognizeVerificationcodeRequest.cc
src/model/RecognizeVerificationcodeResult.cc
src/model/TrimDocumentRequest.cc
src/model/TrimDocumentResult.cc )
add_library(ocr ${LIB_TYPE}
${ocr_public_header}
${ocr_public_header_model}
${ocr_src})
set_target_properties(ocr
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}ocr
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(ocr
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_OCR_LIBRARY)
endif()
target_include_directories(ocr
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(ocr
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(ocr
jsoncpp)
target_include_directories(ocr
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(ocr
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(ocr
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(ocr
PRIVATE /usr/include/jsoncpp)
target_link_libraries(ocr
jsoncpp)
endif()
install(FILES ${ocr_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/ocr)
install(FILES ${ocr_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/ocr/model)
install(TARGETS ocr
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/CMakeLists.txt
|
CMake
|
apache-2.0
| 7,134
|
/*
* 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/DetectCardScreenshotRequest.h"
#include "model/DetectCardScreenshotResult.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/RecognizePoiNameRequest.h"
#include "model/RecognizePoiNameResult.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::DetectCardScreenshotResult> DetectCardScreenshotOutcome;
typedef std::future<DetectCardScreenshotOutcome> DetectCardScreenshotOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::DetectCardScreenshotRequest&, const DetectCardScreenshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCardScreenshotAsyncHandler;
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::RecognizePoiNameResult> RecognizePoiNameOutcome;
typedef std::future<RecognizePoiNameOutcome> RecognizePoiNameOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizePoiNameRequest&, const RecognizePoiNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePoiNameAsyncHandler;
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();
DetectCardScreenshotOutcome detectCardScreenshot(const Model::DetectCardScreenshotRequest &request)const;
void detectCardScreenshotAsync(const Model::DetectCardScreenshotRequest& request, const DetectCardScreenshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectCardScreenshotOutcomeCallable detectCardScreenshotCallable(const Model::DetectCardScreenshotRequest& request) const;
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;
RecognizePoiNameOutcome recognizePoiName(const Model::RecognizePoiNameRequest &request)const;
void recognizePoiNameAsync(const Model::RecognizePoiNameRequest& request, const RecognizePoiNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePoiNameOutcomeCallable recognizePoiNameCallable(const Model::RecognizePoiNameRequest& request) const;
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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/OcrClient.h
|
C++
|
apache-2.0
| 23,463
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/OcrExport.h
|
C
|
apache-2.0
| 1,036
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT DetectCardScreenshotRequest : public RpcServiceRequest
{
public:
DetectCardScreenshotRequest();
~DetectCardScreenshotRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/DetectCardScreenshotRequest.h
|
C++
|
apache-2.0
| 1,340
|
/*
* 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_DETECTCARDSCREENSHOTRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTRESULT_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 DetectCardScreenshotResult : public ServiceResult
{
public:
struct Data
{
struct SpoofResult
{
struct ResultMap
{
float screenScore;
float screenThreshold;
};
ResultMap resultMap;
bool isSpoof;
};
SpoofResult spoofResult;
bool isBlur;
bool isCard;
};
DetectCardScreenshotResult();
explicit DetectCardScreenshotResult(const std::string &payload);
~DetectCardScreenshotResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/DetectCardScreenshotResult.h
|
C++
|
apache-2.0
| 1,664
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/GetAsyncJobResultRequest.h
|
C++
|
apache-2.0
| 1,387
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/GetAsyncJobResultResult.h
|
C++
|
apache-2.0
| 1,528
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeAccountPageRequest.h
|
C++
|
apache-2.0
| 1,430
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeAccountPageResult.h
|
C++
|
apache-2.0
| 2,441
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBankCardRequest.h
|
C++
|
apache-2.0
| 1,412
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBankCardResult.h
|
C++
|
apache-2.0
| 1,479
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardRequest.h
|
C++
|
apache-2.0
| 1,436
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardResult.h
|
C++
|
apache-2.0
| 1,745
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h
|
C++
|
apache-2.0
| 1,454
|
/*
* 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;
float 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseResult.h
|
C++
|
apache-2.0
| 2,186
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeCharacterRequest.h
|
C++
|
apache-2.0
| 1,633
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeCharacterResult.h
|
C++
|
apache-2.0
| 1,689
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeChinapassportRequest.h
|
C++
|
apache-2.0
| 1,352
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeChinapassportResult.h
|
C++
|
apache-2.0
| 2,037
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h
|
C++
|
apache-2.0
| 1,543
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseResult.h
|
C++
|
apache-2.0
| 1,821
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h
|
C++
|
apache-2.0
| 1,549
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseResult.h
|
C++
|
apache-2.0
| 2,188
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h
|
C++
|
apache-2.0
| 1,528
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardResult.h
|
C++
|
apache-2.0
| 2,339
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
|
C++
|
apache-2.0
| 1,436
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateResult.h
|
C++
|
apache-2.0
| 1,710
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
|
C++
|
apache-2.0
| 1,340
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizePassportMRZResult.h
|
C++
|
apache-2.0
| 1,635
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizePoiNameRequest : public RpcServiceRequest
{
public:
RecognizePoiNameRequest();
~RecognizePoiNameRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizePoiNameRequest.h
|
C++
|
apache-2.0
| 1,316
|
/*
* 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_RECOGNIZEPOINAMERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMERESULT_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 RecognizePoiNameResult : public ServiceResult
{
public:
struct Data
{
struct Summary
{
std::string brand;
float score;
};
struct SignboardsItem
{
struct TextsItem
{
float score;
std::string type;
std::vector<std::string> points;
std::string label;
std::string tag;
};
std::vector<SignboardsItem::TextsItem> texts;
};
std::vector<SignboardsItem> signboards;
Summary summary;
};
RecognizePoiNameResult();
explicit RecognizePoiNameResult(const std::string &payload);
~RecognizePoiNameResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizePoiNameResult.h
|
C++
|
apache-2.0
| 1,803
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h
|
C++
|
apache-2.0
| 1,384
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeQrCodeResult.h
|
C++
|
apache-2.0
| 1,708
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeStampRequest.h
|
C++
|
apache-2.0
| 1,394
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeStampResult.h
|
C++
|
apache-2.0
| 1,836
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTableRequest.h
|
C++
|
apache-2.0
| 1,955
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTableResult.h
|
C++
|
apache-2.0
| 1,898
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h
|
C++
|
apache-2.0
| 1,346
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderResult.h
|
C++
|
apache-2.0
| 1,600
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h
|
C++
|
apache-2.0
| 1,430
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceResult.h
|
C++
|
apache-2.0
| 2,027
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
|
C++
|
apache-2.0
| 1,430
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
|
C++
|
apache-2.0
| 1,617
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
|
C++
|
apache-2.0
| 1,447
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceResult.h
|
C++
|
apache-2.0
| 2,955
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
|
C++
|
apache-2.0
| 1,406
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVINCodeResult.h
|
C++
|
apache-2.0
| 1,414
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h
|
C++
|
apache-2.0
| 1,370
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeResult.h
|
C++
|
apache-2.0
| 1,477
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/TrimDocumentRequest.h
|
C++
|
apache-2.0
| 1,607
|
/*
* 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/include/alibabacloud/ocr/model/TrimDocumentResult.h
|
C++
|
apache-2.0
| 1,386
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/OcrClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
namespace
{
const std::string SERVICE_NAME = "ocr";
}
OcrClient::OcrClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ocr");
}
OcrClient::OcrClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ocr");
}
OcrClient::OcrClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ocr");
}
OcrClient::~OcrClient()
{}
OcrClient::DetectCardScreenshotOutcome OcrClient::detectCardScreenshot(const DetectCardScreenshotRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectCardScreenshotOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectCardScreenshotOutcome(DetectCardScreenshotResult(outcome.result()));
else
return DetectCardScreenshotOutcome(outcome.error());
}
void OcrClient::detectCardScreenshotAsync(const DetectCardScreenshotRequest& request, const DetectCardScreenshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectCardScreenshot(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::DetectCardScreenshotOutcomeCallable OcrClient::detectCardScreenshotCallable(const DetectCardScreenshotRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectCardScreenshotOutcome()>>(
[this, request]()
{
return this->detectCardScreenshot(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::GetAsyncJobResultOutcome OcrClient::getAsyncJobResult(const GetAsyncJobResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAsyncJobResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAsyncJobResultOutcome(GetAsyncJobResultResult(outcome.result()));
else
return GetAsyncJobResultOutcome(outcome.error());
}
void OcrClient::getAsyncJobResultAsync(const GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAsyncJobResult(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::GetAsyncJobResultOutcomeCallable OcrClient::getAsyncJobResultCallable(const GetAsyncJobResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAsyncJobResultOutcome()>>(
[this, request]()
{
return this->getAsyncJobResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeAccountPageOutcome OcrClient::recognizeAccountPage(const RecognizeAccountPageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeAccountPageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeAccountPageOutcome(RecognizeAccountPageResult(outcome.result()));
else
return RecognizeAccountPageOutcome(outcome.error());
}
void OcrClient::recognizeAccountPageAsync(const RecognizeAccountPageRequest& request, const RecognizeAccountPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeAccountPage(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeAccountPageOutcomeCallable OcrClient::recognizeAccountPageCallable(const RecognizeAccountPageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeAccountPageOutcome()>>(
[this, request]()
{
return this->recognizeAccountPage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeBankCardOutcome OcrClient::recognizeBankCard(const RecognizeBankCardRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeBankCardOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeBankCardOutcome(RecognizeBankCardResult(outcome.result()));
else
return RecognizeBankCardOutcome(outcome.error());
}
void OcrClient::recognizeBankCardAsync(const RecognizeBankCardRequest& request, const RecognizeBankCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeBankCard(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeBankCardOutcomeCallable OcrClient::recognizeBankCardCallable(const RecognizeBankCardRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeBankCardOutcome()>>(
[this, request]()
{
return this->recognizeBankCard(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeBusinessCardOutcome OcrClient::recognizeBusinessCard(const RecognizeBusinessCardRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeBusinessCardOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeBusinessCardOutcome(RecognizeBusinessCardResult(outcome.result()));
else
return RecognizeBusinessCardOutcome(outcome.error());
}
void OcrClient::recognizeBusinessCardAsync(const RecognizeBusinessCardRequest& request, const RecognizeBusinessCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeBusinessCard(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeBusinessCardOutcomeCallable OcrClient::recognizeBusinessCardCallable(const RecognizeBusinessCardRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeBusinessCardOutcome()>>(
[this, request]()
{
return this->recognizeBusinessCard(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeBusinessLicenseOutcome OcrClient::recognizeBusinessLicense(const RecognizeBusinessLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeBusinessLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeBusinessLicenseOutcome(RecognizeBusinessLicenseResult(outcome.result()));
else
return RecognizeBusinessLicenseOutcome(outcome.error());
}
void OcrClient::recognizeBusinessLicenseAsync(const RecognizeBusinessLicenseRequest& request, const RecognizeBusinessLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeBusinessLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeBusinessLicenseOutcomeCallable OcrClient::recognizeBusinessLicenseCallable(const RecognizeBusinessLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeBusinessLicenseOutcome()>>(
[this, request]()
{
return this->recognizeBusinessLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeCharacterOutcome OcrClient::recognizeCharacter(const RecognizeCharacterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeCharacterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeCharacterOutcome(RecognizeCharacterResult(outcome.result()));
else
return RecognizeCharacterOutcome(outcome.error());
}
void OcrClient::recognizeCharacterAsync(const RecognizeCharacterRequest& request, const RecognizeCharacterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeCharacter(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeCharacterOutcomeCallable OcrClient::recognizeCharacterCallable(const RecognizeCharacterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeCharacterOutcome()>>(
[this, request]()
{
return this->recognizeCharacter(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeChinapassportOutcome OcrClient::recognizeChinapassport(const RecognizeChinapassportRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeChinapassportOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeChinapassportOutcome(RecognizeChinapassportResult(outcome.result()));
else
return RecognizeChinapassportOutcome(outcome.error());
}
void OcrClient::recognizeChinapassportAsync(const RecognizeChinapassportRequest& request, const RecognizeChinapassportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeChinapassport(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeChinapassportOutcomeCallable OcrClient::recognizeChinapassportCallable(const RecognizeChinapassportRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeChinapassportOutcome()>>(
[this, request]()
{
return this->recognizeChinapassport(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeDriverLicenseOutcome OcrClient::recognizeDriverLicense(const RecognizeDriverLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeDriverLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeDriverLicenseOutcome(RecognizeDriverLicenseResult(outcome.result()));
else
return RecognizeDriverLicenseOutcome(outcome.error());
}
void OcrClient::recognizeDriverLicenseAsync(const RecognizeDriverLicenseRequest& request, const RecognizeDriverLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeDriverLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeDriverLicenseOutcomeCallable OcrClient::recognizeDriverLicenseCallable(const RecognizeDriverLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeDriverLicenseOutcome()>>(
[this, request]()
{
return this->recognizeDriverLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeDrivingLicenseOutcome OcrClient::recognizeDrivingLicense(const RecognizeDrivingLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeDrivingLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeDrivingLicenseOutcome(RecognizeDrivingLicenseResult(outcome.result()));
else
return RecognizeDrivingLicenseOutcome(outcome.error());
}
void OcrClient::recognizeDrivingLicenseAsync(const RecognizeDrivingLicenseRequest& request, const RecognizeDrivingLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeDrivingLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeDrivingLicenseOutcomeCallable OcrClient::recognizeDrivingLicenseCallable(const RecognizeDrivingLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeDrivingLicenseOutcome()>>(
[this, request]()
{
return this->recognizeDrivingLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeIdentityCardOutcome OcrClient::recognizeIdentityCard(const RecognizeIdentityCardRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeIdentityCardOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeIdentityCardOutcome(RecognizeIdentityCardResult(outcome.result()));
else
return RecognizeIdentityCardOutcome(outcome.error());
}
void OcrClient::recognizeIdentityCardAsync(const RecognizeIdentityCardRequest& request, const RecognizeIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeIdentityCard(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeIdentityCardOutcomeCallable OcrClient::recognizeIdentityCardCallable(const RecognizeIdentityCardRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeIdentityCardOutcome()>>(
[this, request]()
{
return this->recognizeIdentityCard(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeLicensePlateOutcome OcrClient::recognizeLicensePlate(const RecognizeLicensePlateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeLicensePlateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeLicensePlateOutcome(RecognizeLicensePlateResult(outcome.result()));
else
return RecognizeLicensePlateOutcome(outcome.error());
}
void OcrClient::recognizeLicensePlateAsync(const RecognizeLicensePlateRequest& request, const RecognizeLicensePlateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeLicensePlate(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeLicensePlateOutcomeCallable OcrClient::recognizeLicensePlateCallable(const RecognizeLicensePlateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeLicensePlateOutcome()>>(
[this, request]()
{
return this->recognizeLicensePlate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizePassportMRZOutcome OcrClient::recognizePassportMRZ(const RecognizePassportMRZRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizePassportMRZOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizePassportMRZOutcome(RecognizePassportMRZResult(outcome.result()));
else
return RecognizePassportMRZOutcome(outcome.error());
}
void OcrClient::recognizePassportMRZAsync(const RecognizePassportMRZRequest& request, const RecognizePassportMRZAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizePassportMRZ(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizePassportMRZOutcomeCallable OcrClient::recognizePassportMRZCallable(const RecognizePassportMRZRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizePassportMRZOutcome()>>(
[this, request]()
{
return this->recognizePassportMRZ(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizePoiNameOutcome OcrClient::recognizePoiName(const RecognizePoiNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizePoiNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizePoiNameOutcome(RecognizePoiNameResult(outcome.result()));
else
return RecognizePoiNameOutcome(outcome.error());
}
void OcrClient::recognizePoiNameAsync(const RecognizePoiNameRequest& request, const RecognizePoiNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizePoiName(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizePoiNameOutcomeCallable OcrClient::recognizePoiNameCallable(const RecognizePoiNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizePoiNameOutcome()>>(
[this, request]()
{
return this->recognizePoiName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeQrCodeOutcome OcrClient::recognizeQrCode(const RecognizeQrCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeQrCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeQrCodeOutcome(RecognizeQrCodeResult(outcome.result()));
else
return RecognizeQrCodeOutcome(outcome.error());
}
void OcrClient::recognizeQrCodeAsync(const RecognizeQrCodeRequest& request, const RecognizeQrCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeQrCode(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeQrCodeOutcomeCallable OcrClient::recognizeQrCodeCallable(const RecognizeQrCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeQrCodeOutcome()>>(
[this, request]()
{
return this->recognizeQrCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeStampOutcome OcrClient::recognizeStamp(const RecognizeStampRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeStampOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeStampOutcome(RecognizeStampResult(outcome.result()));
else
return RecognizeStampOutcome(outcome.error());
}
void OcrClient::recognizeStampAsync(const RecognizeStampRequest& request, const RecognizeStampAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeStamp(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeStampOutcomeCallable OcrClient::recognizeStampCallable(const RecognizeStampRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeStampOutcome()>>(
[this, request]()
{
return this->recognizeStamp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeTableOutcome OcrClient::recognizeTable(const RecognizeTableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeTableOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeTableOutcome(RecognizeTableResult(outcome.result()));
else
return RecognizeTableOutcome(outcome.error());
}
void OcrClient::recognizeTableAsync(const RecognizeTableRequest& request, const RecognizeTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeTable(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeTableOutcomeCallable OcrClient::recognizeTableCallable(const RecognizeTableRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeTableOutcome()>>(
[this, request]()
{
return this->recognizeTable(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeTakeoutOrderOutcome OcrClient::recognizeTakeoutOrder(const RecognizeTakeoutOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeTakeoutOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeTakeoutOrderOutcome(RecognizeTakeoutOrderResult(outcome.result()));
else
return RecognizeTakeoutOrderOutcome(outcome.error());
}
void OcrClient::recognizeTakeoutOrderAsync(const RecognizeTakeoutOrderRequest& request, const RecognizeTakeoutOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeTakeoutOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeTakeoutOrderOutcomeCallable OcrClient::recognizeTakeoutOrderCallable(const RecognizeTakeoutOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeTakeoutOrderOutcome()>>(
[this, request]()
{
return this->recognizeTakeoutOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeTaxiInvoiceOutcome OcrClient::recognizeTaxiInvoice(const RecognizeTaxiInvoiceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeTaxiInvoiceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeTaxiInvoiceOutcome(RecognizeTaxiInvoiceResult(outcome.result()));
else
return RecognizeTaxiInvoiceOutcome(outcome.error());
}
void OcrClient::recognizeTaxiInvoiceAsync(const RecognizeTaxiInvoiceRequest& request, const RecognizeTaxiInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeTaxiInvoice(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeTaxiInvoiceOutcomeCallable OcrClient::recognizeTaxiInvoiceCallable(const RecognizeTaxiInvoiceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeTaxiInvoiceOutcome()>>(
[this, request]()
{
return this->recognizeTaxiInvoice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeTrainTicketOutcome OcrClient::recognizeTrainTicket(const RecognizeTrainTicketRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeTrainTicketOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeTrainTicketOutcome(RecognizeTrainTicketResult(outcome.result()));
else
return RecognizeTrainTicketOutcome(outcome.error());
}
void OcrClient::recognizeTrainTicketAsync(const RecognizeTrainTicketRequest& request, const RecognizeTrainTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeTrainTicket(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeTrainTicketOutcomeCallable OcrClient::recognizeTrainTicketCallable(const RecognizeTrainTicketRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeTrainTicketOutcome()>>(
[this, request]()
{
return this->recognizeTrainTicket(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeVATInvoiceOutcome OcrClient::recognizeVATInvoice(const RecognizeVATInvoiceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVATInvoiceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVATInvoiceOutcome(RecognizeVATInvoiceResult(outcome.result()));
else
return RecognizeVATInvoiceOutcome(outcome.error());
}
void OcrClient::recognizeVATInvoiceAsync(const RecognizeVATInvoiceRequest& request, const RecognizeVATInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVATInvoice(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeVATInvoiceOutcomeCallable OcrClient::recognizeVATInvoiceCallable(const RecognizeVATInvoiceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVATInvoiceOutcome()>>(
[this, request]()
{
return this->recognizeVATInvoice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeVINCodeOutcome OcrClient::recognizeVINCode(const RecognizeVINCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVINCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVINCodeOutcome(RecognizeVINCodeResult(outcome.result()));
else
return RecognizeVINCodeOutcome(outcome.error());
}
void OcrClient::recognizeVINCodeAsync(const RecognizeVINCodeRequest& request, const RecognizeVINCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVINCode(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeVINCodeOutcomeCallable OcrClient::recognizeVINCodeCallable(const RecognizeVINCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVINCodeOutcome()>>(
[this, request]()
{
return this->recognizeVINCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeVerificationcodeOutcome OcrClient::recognizeVerificationcode(const RecognizeVerificationcodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVerificationcodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVerificationcodeOutcome(RecognizeVerificationcodeResult(outcome.result()));
else
return RecognizeVerificationcodeOutcome(outcome.error());
}
void OcrClient::recognizeVerificationcodeAsync(const RecognizeVerificationcodeRequest& request, const RecognizeVerificationcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVerificationcode(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeVerificationcodeOutcomeCallable OcrClient::recognizeVerificationcodeCallable(const RecognizeVerificationcodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVerificationcodeOutcome()>>(
[this, request]()
{
return this->recognizeVerificationcode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::TrimDocumentOutcome OcrClient::trimDocument(const TrimDocumentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TrimDocumentOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TrimDocumentOutcome(TrimDocumentResult(outcome.result()));
else
return TrimDocumentOutcome(outcome.error());
}
void OcrClient::trimDocumentAsync(const TrimDocumentRequest& request, const TrimDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, trimDocument(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::TrimDocumentOutcomeCallable OcrClient::trimDocumentCallable(const TrimDocumentRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TrimDocumentOutcome()>>(
[this, request]()
{
return this->trimDocument(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/OcrClient.cc
|
C++
|
apache-2.0
| 32,256
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/DetectCardScreenshotRequest.h>
using AlibabaCloud::Ocr::Model::DetectCardScreenshotRequest;
DetectCardScreenshotRequest::DetectCardScreenshotRequest() :
RpcServiceRequest("ocr", "2019-12-30", "DetectCardScreenshot")
{
setMethod(HttpRequest::Method::Post);
}
DetectCardScreenshotRequest::~DetectCardScreenshotRequest()
{}
std::string DetectCardScreenshotRequest::getImageURL()const
{
return imageURL_;
}
void DetectCardScreenshotRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/DetectCardScreenshotRequest.cc
|
C++
|
apache-2.0
| 1,229
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/DetectCardScreenshotResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
DetectCardScreenshotResult::DetectCardScreenshotResult() :
ServiceResult()
{}
DetectCardScreenshotResult::DetectCardScreenshotResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectCardScreenshotResult::~DetectCardScreenshotResult()
{}
void DetectCardScreenshotResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["IsCard"].isNull())
data_.isCard = dataNode["IsCard"].asString() == "true";
if(!dataNode["IsBlur"].isNull())
data_.isBlur = dataNode["IsBlur"].asString() == "true";
auto spoofResultNode = dataNode["SpoofResult"];
if(!spoofResultNode["IsSpoof"].isNull())
data_.spoofResult.isSpoof = spoofResultNode["IsSpoof"].asString() == "true";
auto resultMapNode = spoofResultNode["ResultMap"];
if(!resultMapNode["ScreenScore"].isNull())
data_.spoofResult.resultMap.screenScore = std::stof(resultMapNode["ScreenScore"].asString());
if(!resultMapNode["ScreenThreshold"].isNull())
data_.spoofResult.resultMap.screenThreshold = std::stof(resultMapNode["ScreenThreshold"].asString());
}
DetectCardScreenshotResult::Data DetectCardScreenshotResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/DetectCardScreenshotResult.cc
|
C++
|
apache-2.0
| 2,077
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Ocr::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("ocr", "2019-12-30", "GetAsyncJobResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
{}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/GetAsyncJobResultRequest.cc
|
C++
|
apache-2.0
| 1,385
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/GetAsyncJobResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
GetAsyncJobResultResult::GetAsyncJobResultResult() :
ServiceResult()
{}
GetAsyncJobResultResult::GetAsyncJobResultResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAsyncJobResultResult::~GetAsyncJobResultResult()
{}
void GetAsyncJobResultResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
}
GetAsyncJobResultResult::Data GetAsyncJobResultResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/GetAsyncJobResultResult.cc
|
C++
|
apache-2.0
| 1,783
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeAccountPageRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeAccountPageRequest;
RecognizeAccountPageRequest::RecognizeAccountPageRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeAccountPage")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeAccountPageRequest::~RecognizeAccountPageRequest()
{}
int RecognizeAccountPageRequest::getImageType()const
{
return imageType_;
}
void RecognizeAccountPageRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string RecognizeAccountPageRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeAccountPageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/RecognizeAccountPageRequest.cc
|
C++
|
apache-2.0
| 1,469
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeAccountPageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
RecognizeAccountPageResult::RecognizeAccountPageResult() :
ServiceResult()
{}
RecognizeAccountPageResult::RecognizeAccountPageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeAccountPageResult::~RecognizeAccountPageResult()
{}
void RecognizeAccountPageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Angle"].isNull())
data_.angle = std::stof(dataNode["Angle"].asString());
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["Gender"].isNull())
data_.gender = dataNode["Gender"].asString();
if(!dataNode["Relation"].isNull())
data_.relation = dataNode["Relation"].asString();
if(!dataNode["BirthPlace"].isNull())
data_.birthPlace = dataNode["BirthPlace"].asString();
if(!dataNode["Nationality"].isNull())
data_.nationality = dataNode["Nationality"].asString();
if(!dataNode["NativePlace"].isNull())
data_.nativePlace = dataNode["NativePlace"].asString();
if(!dataNode["BirthDate"].isNull())
data_.birthDate = dataNode["BirthDate"].asString();
if(!dataNode["IDNumber"].isNull())
data_.iDNumber = dataNode["IDNumber"].asString();
auto allInvalidStampAreasNode = dataNode["InvalidStampAreas"]["InvalidStampArea"];
for (auto dataNodeInvalidStampAreasInvalidStampArea : allInvalidStampAreasNode)
{
Data::InvalidStampArea invalidStampAreaObject;
if(!dataNodeInvalidStampAreasInvalidStampArea["Left"].isNull())
invalidStampAreaObject.left = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Left"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Top"].isNull())
invalidStampAreaObject.top = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Top"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Height"].isNull())
invalidStampAreaObject.height = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Height"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Width"].isNull())
invalidStampAreaObject.width = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Width"].asString());
data_.invalidStampAreas.push_back(invalidStampAreaObject);
}
auto allUndertakeStampAreasNode = dataNode["UndertakeStampAreas"]["UndertakeStampArea"];
for (auto dataNodeUndertakeStampAreasUndertakeStampArea : allUndertakeStampAreasNode)
{
Data::UndertakeStampArea undertakeStampAreaObject;
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Left"].isNull())
undertakeStampAreaObject.left = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Left"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Top"].isNull())
undertakeStampAreaObject.top = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Top"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Height"].isNull())
undertakeStampAreaObject.height = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Height"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Width"].isNull())
undertakeStampAreaObject.width = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Width"].asString());
data_.undertakeStampAreas.push_back(undertakeStampAreaObject);
}
auto allRegisterStampAreasNode = dataNode["RegisterStampAreas"]["RegisterStampArea"];
for (auto dataNodeRegisterStampAreasRegisterStampArea : allRegisterStampAreasNode)
{
Data::RegisterStampArea registerStampAreaObject;
if(!dataNodeRegisterStampAreasRegisterStampArea["Left"].isNull())
registerStampAreaObject.left = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Left"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Top"].isNull())
registerStampAreaObject.top = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Top"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Height"].isNull())
registerStampAreaObject.height = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Height"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Width"].isNull())
registerStampAreaObject.width = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Width"].asString());
data_.registerStampAreas.push_back(registerStampAreaObject);
}
auto allOtherStampAreasNode = dataNode["OtherStampAreas"]["OtherStampArea"];
for (auto dataNodeOtherStampAreasOtherStampArea : allOtherStampAreasNode)
{
Data::OtherStampArea otherStampAreaObject;
if(!dataNodeOtherStampAreasOtherStampArea["Left"].isNull())
otherStampAreaObject.left = std::stoi(dataNodeOtherStampAreasOtherStampArea["Left"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Top"].isNull())
otherStampAreaObject.top = std::stoi(dataNodeOtherStampAreasOtherStampArea["Top"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Height"].isNull())
otherStampAreaObject.height = std::stoi(dataNodeOtherStampAreasOtherStampArea["Height"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Width"].isNull())
otherStampAreaObject.width = std::stoi(dataNodeOtherStampAreasOtherStampArea["Width"].asString());
data_.otherStampAreas.push_back(otherStampAreaObject);
}
auto titleAreaNode = dataNode["TitleArea"];
if(!titleAreaNode["Left"].isNull())
data_.titleArea.left = std::stoi(titleAreaNode["Left"].asString());
if(!titleAreaNode["Top"].isNull())
data_.titleArea.top = std::stoi(titleAreaNode["Top"].asString());
if(!titleAreaNode["Height"].isNull())
data_.titleArea.height = std::stoi(titleAreaNode["Height"].asString());
if(!titleAreaNode["Width"].isNull())
data_.titleArea.width = std::stoi(titleAreaNode["Width"].asString());
}
RecognizeAccountPageResult::Data RecognizeAccountPageResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/RecognizeAccountPageResult.cc
|
C++
|
apache-2.0
| 6,591
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeBankCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBankCardRequest;
RecognizeBankCardRequest::RecognizeBankCardRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeBankCard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeBankCardRequest::~RecognizeBankCardRequest()
{}
int RecognizeBankCardRequest::getImageType()const
{
return imageType_;
}
void RecognizeBankCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string RecognizeBankCardRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeBankCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/RecognizeBankCardRequest.cc
|
C++
|
apache-2.0
| 1,436
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeBankCardResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
RecognizeBankCardResult::RecognizeBankCardResult() :
ServiceResult()
{}
RecognizeBankCardResult::RecognizeBankCardResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeBankCardResult::~RecognizeBankCardResult()
{}
void RecognizeBankCardResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["BankName"].isNull())
data_.bankName = dataNode["BankName"].asString();
if(!dataNode["CardNumber"].isNull())
data_.cardNumber = dataNode["CardNumber"].asString();
if(!dataNode["ValidDate"].isNull())
data_.validDate = dataNode["ValidDate"].asString();
}
RecognizeBankCardResult::Data RecognizeBankCardResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/ocr/src/model/RecognizeBankCardResult.cc
|
C++
|
apache-2.0
| 1,622
|