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

Update imageaudit.

Browse Source
This commit is contained in:
sdk-team
2022-11-10 09:00:50 +00:00
parent 43fef9b25b
commit 675df848ba
8 changed files with 210 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1332 1.36.1333

90
imageaudit/include/alibabacloud/imageaudit/model/ScanImageRequest.h
View File

@@ -1,60 +1,52 @@
/* /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved. * Copyright 2009-2017 Alibaba Cloud All rights reserved.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_ #ifndef ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_ #define ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_
#include <string> #include <alibabacloud/imageaudit/ImageauditExport.h>
#include <vector> #include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/core/RpcServiceRequest.h> #include <string>
#include <alibabacloud/imageaudit/ImageauditExport.h> #include <vector>
#include <map>
namespace AlibabaCloud
{ namespace AlibabaCloud {
namespace Imageaudit namespace Imageaudit {
{ namespace Model {
namespace Model class ALIBABACLOUD_IMAGEAUDIT_EXPORT ScanImageRequest : public RpcServiceRequest {
{ public:
class ALIBABACLOUD_IMAGEAUDIT_EXPORT ScanImageRequest : public RpcServiceRequest struct Task {
{ std::string dataId;
public: std::string imageURL;
struct Task int maxFrames;
{ int interval;
std::string dataId; long imageTimeMillisecond;
std::string imageURL; };
int maxFrames; ScanImageRequest();
int interval; ~ScanImageRequest();
long imageTimeMillisecond; std::vector<std::string> getScene() const;
}; void setScene(const std::vector<std::string> &scene);
std::vector<Task> getTask() const;
public: void setTask(const std::vector<Task> &task);
ScanImageRequest();
~ScanImageRequest(); private:
std::vector<std::string> scene_;
std::vector<std::string> getScene()const; std::vector<Task> task_;
void setScene(const std::vector<std::string>& scene); };
std::vector<Task> getTask()const; } // namespace Model
void setTask(const std::vector<Task>& task); } // namespace Imageaudit
} // namespace AlibabaCloud
private: #endif // !ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_
std::vector<std::string> scene_;
std::vector<Task> task_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANIMAGEREQUEST_H_

26
imageaudit/include/alibabacloud/imageaudit/model/ScanImageResult.h
View File

@@ -38,11 +38,6 @@ namespace AlibabaCloud
{ {
struct SubResult struct SubResult
{ {
struct Frame
{
float rate;
std::string uRL;
};
struct SfaceData struct SfaceData
{ {
struct Face struct Face
@@ -61,6 +56,18 @@ namespace AlibabaCloud
{ {
std::string context; std::string context;
}; };
struct ProgramCodeData
{
float x;
float y;
float height;
float width;
};
struct Frame
{
float rate;
std::string uRL;
};
struct LogoData struct LogoData
{ {
std::string type; std::string type;
@@ -70,13 +77,6 @@ namespace AlibabaCloud
float width; float width;
std::string name; std::string name;
}; };
struct ProgramCodeData
{
float x;
float y;
float height;
float width;
};
std::vector<SubResult::Frame> frames; std::vector<SubResult::Frame> frames;
std::string suggestion; std::string suggestion;
std::vector<SubResult::SfaceData> sfaceDataList; std::vector<SubResult::SfaceData> sfaceDataList;
@@ -88,8 +88,8 @@ namespace AlibabaCloud
std::string scene; std::string scene;
std::vector<SubResult::ProgramCodeData> programCodeDataList; std::vector<SubResult::ProgramCodeData> programCodeDataList;
}; };
std::string taskId;
std::string dataId; std::string dataId;
std::string taskId;
std::string imageURL; std::string imageURL;
std::vector<Result::SubResult> subResults; std::vector<Result::SubResult> subResults;
}; };

89
imageaudit/include/alibabacloud/imageaudit/model/ScanTextRequest.h
View File

@@ -1,60 +1,51 @@
/* /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved. * Copyright 2009-2017 Alibaba Cloud All rights reserved.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_ #ifndef ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_
#define ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_ #define ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_
#include <string> #include <alibabacloud/imageaudit/ImageauditExport.h>
#include <vector> #include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/core/RpcServiceRequest.h> #include <string>
#include <alibabacloud/imageaudit/ImageauditExport.h> #include <vector>
#include <map>
namespace AlibabaCloud
{ namespace AlibabaCloud {
namespace Imageaudit namespace Imageaudit {
{ namespace Model {
namespace Model class ALIBABACLOUD_IMAGEAUDIT_EXPORT ScanTextRequest : public RpcServiceRequest {
{ public:
class ALIBABACLOUD_IMAGEAUDIT_EXPORT ScanTextRequest : public RpcServiceRequest struct Labels {
{ std::string label;
public: };
struct Labels struct Tasks {
{ std::string content;
std::string label; };
}; ScanTextRequest();
struct Tasks ~ScanTextRequest();
{ std::vector<Labels> getLabels() const;
std::string content; void setLabels(const std::vector<Labels> &labels);
}; std::vector<Tasks> getTasks() const;
void setTasks(const std::vector<Tasks> &tasks);
public:
ScanTextRequest(); private:
~ScanTextRequest(); std::vector<Labels> labels_;
std::vector<Tasks> tasks_;
std::vector<Labels> getLabels()const; };
void setLabels(const std::vector<Labels>& labels); } // namespace Model
std::vector<Tasks> getTasks()const; } // namespace Imageaudit
void setTasks(const std::vector<Tasks>& tasks); } // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_
private:
std::vector<Labels> labels_;
std::vector<Tasks> tasks_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEAUDIT_MODEL_SCANTEXTREQUEST_H_

75
imageaudit/src/model/ScanImageRequest.cc
View File

@@ -1,61 +1,52 @@
/* /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved. * Copyright 2009-2017 Alibaba Cloud All rights reserved.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include <alibabacloud/imageaudit/model/ScanImageRequest.h> #include <alibabacloud/imageaudit/model/ScanImageRequest.h>
using AlibabaCloud::Imageaudit::Model::ScanImageRequest; using AlibabaCloud::Imageaudit::Model::ScanImageRequest;
ScanImageRequest::ScanImageRequest() : ScanImageRequest::ScanImageRequest()
RpcServiceRequest("imageaudit", "2019-12-30", "ScanImage") : RpcServiceRequest("imageaudit", "2019-12-30", "ScanImage") {
{ setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::Post);
}
ScanImageRequest::~ScanImageRequest()
{}
std::vector<std::string> ScanImageRequest::getScene()const
{
return scene_;
} }
void ScanImageRequest::setScene(const std::vector<std::string>& scene) ScanImageRequest::~ScanImageRequest() {}
{
scene_ = scene; std::vector<std::string> ScanImageRequest::getScene() const {
for(int dep1 = 0; dep1!= scene.size(); dep1++) { return scene_;
setBodyParameter("Scene."+ std::to_string(dep1), scene.at(dep1));
}
} }
std::vector<ScanImageRequest::Task> ScanImageRequest::getTask()const void ScanImageRequest::setScene(const std::vector<std::string> &scene) {
{ scene_ = scene;
return task_;
} }
void ScanImageRequest::setTask(const std::vector<Task>& task) std::vector<ScanImageRequest::Task> ScanImageRequest::getTask() const {
{ return task_;
task_ = task; }
for(int dep1 = 0; dep1!= task.size(); dep1++) {
auto taskObj = task.at(dep1); void ScanImageRequest::setTask(const std::vector<ScanImageRequest::Task> &task) {
std::string taskObjStr = "Task." + std::to_string(dep1 + 1); task_ = task;
setParameter(taskObjStr + ".DataId", taskObj.dataId); for(int dep1 = 0; dep1 != task.size(); dep1++) {
setParameter(taskObjStr + ".ImageURL", taskObj.imageURL); auto taskObj = task.at(dep1);
setParameter(taskObjStr + ".MaxFrames", std::to_string(taskObj.maxFrames)); std::string taskObjStr = std::string("Task") + "." + std::to_string(dep1 + 1);
setParameter(taskObjStr + ".Interval", std::to_string(taskObj.interval)); setBodyParameter(taskObjStr + ".DataId", taskObj.dataId);
setParameter(taskObjStr + ".ImageTimeMillisecond", std::to_string(taskObj.imageTimeMillisecond)); setBodyParameter(taskObjStr + ".ImageURL", taskObj.imageURL);
} setBodyParameter(taskObjStr + ".MaxFrames", std::to_string(taskObj.maxFrames));
setBodyParameter(taskObjStr + ".Interval", std::to_string(taskObj.interval));
setBodyParameter(taskObjStr + ".ImageTimeMillisecond", std::to_string(taskObj.imageTimeMillisecond));
}
} }

92
imageaudit/src/model/ScanImageResult.cc
View File

@@ -44,56 +44,46 @@ void ScanImageResult::parse(const std::string &payload)
for (auto dataNodeResultsResult : allResultsNode) for (auto dataNodeResultsResult : allResultsNode)
{ {
Data::Result resultObject; Data::Result resultObject;
if(!dataNodeResultsResult["TaskId"].isNull())
resultObject.taskId = dataNodeResultsResult["TaskId"].asString();
if(!dataNodeResultsResult["DataId"].isNull())
resultObject.dataId = dataNodeResultsResult["DataId"].asString();
if(!dataNodeResultsResult["ImageURL"].isNull()) if(!dataNodeResultsResult["ImageURL"].isNull())
resultObject.imageURL = dataNodeResultsResult["ImageURL"].asString(); resultObject.imageURL = dataNodeResultsResult["ImageURL"].asString();
if(!dataNodeResultsResult["DataId"].isNull())
resultObject.dataId = dataNodeResultsResult["DataId"].asString();
if(!dataNodeResultsResult["TaskId"].isNull())
resultObject.taskId = dataNodeResultsResult["TaskId"].asString();
auto allSubResultsNode = dataNodeResultsResult["SubResults"]["SubResult"]; auto allSubResultsNode = dataNodeResultsResult["SubResults"]["SubResult"];
for (auto dataNodeResultsResultSubResultsSubResult : allSubResultsNode) for (auto dataNodeResultsResultSubResultsSubResult : allSubResultsNode)
{ {
Data::Result::SubResult subResultsObject; Data::Result::SubResult subResultsObject;
if(!dataNodeResultsResultSubResultsSubResult["Suggestion"].isNull()) if(!dataNodeResultsResultSubResultsSubResult["Suggestion"].isNull())
subResultsObject.suggestion = dataNodeResultsResultSubResultsSubResult["Suggestion"].asString(); subResultsObject.suggestion = dataNodeResultsResultSubResultsSubResult["Suggestion"].asString();
if(!dataNodeResultsResultSubResultsSubResult["Rate"].isNull())
subResultsObject.rate = std::stof(dataNodeResultsResultSubResultsSubResult["Rate"].asString());
if(!dataNodeResultsResultSubResultsSubResult["Label"].isNull()) if(!dataNodeResultsResultSubResultsSubResult["Label"].isNull())
subResultsObject.label = dataNodeResultsResultSubResultsSubResult["Label"].asString(); subResultsObject.label = dataNodeResultsResultSubResultsSubResult["Label"].asString();
if(!dataNodeResultsResultSubResultsSubResult["Scene"].isNull()) if(!dataNodeResultsResultSubResultsSubResult["Scene"].isNull())
subResultsObject.scene = dataNodeResultsResultSubResultsSubResult["Scene"].asString(); subResultsObject.scene = dataNodeResultsResultSubResultsSubResult["Scene"].asString();
auto allFramesNode = dataNodeResultsResultSubResultsSubResult["Frames"]["Frame"]; if(!dataNodeResultsResultSubResultsSubResult["Rate"].isNull())
for (auto dataNodeResultsResultSubResultsSubResultFramesFrame : allFramesNode) subResultsObject.rate = std::stof(dataNodeResultsResultSubResultsSubResult["Rate"].asString());
{
Data::Result::SubResult::Frame framesObject;
if(!dataNodeResultsResultSubResultsSubResultFramesFrame["Rate"].isNull())
framesObject.rate = std::stof(dataNodeResultsResultSubResultsSubResultFramesFrame["Rate"].asString());
if(!dataNodeResultsResultSubResultsSubResultFramesFrame["URL"].isNull())
framesObject.uRL = dataNodeResultsResultSubResultsSubResultFramesFrame["URL"].asString();
subResultsObject.frames.push_back(framesObject);
}
auto allSfaceDataListNode = dataNodeResultsResultSubResultsSubResult["SfaceDataList"]["SfaceData"]; auto allSfaceDataListNode = dataNodeResultsResultSubResultsSubResult["SfaceDataList"]["SfaceData"];
for (auto dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData : allSfaceDataListNode) for (auto dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData : allSfaceDataListNode)
{ {
Data::Result::SubResult::SfaceData sfaceDataListObject; Data::Result::SubResult::SfaceData sfaceDataListObject;
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["X"].isNull())
sfaceDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["X"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Y"].isNull())
sfaceDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Height"].isNull())
sfaceDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Width"].isNull()) if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Width"].isNull())
sfaceDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Width"].asString()); sfaceDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Width"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Height"].isNull())
sfaceDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Y"].isNull())
sfaceDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["X"].isNull())
sfaceDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["X"].asString());
auto allFacesNode = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Faces"]["Face"]; auto allFacesNode = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceData["Faces"]["Face"];
for (auto dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace : allFacesNode) for (auto dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace : allFacesNode)
{ {
Data::Result::SubResult::SfaceData::Face facesObject; Data::Result::SubResult::SfaceData::Face facesObject;
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Rate"].isNull())
facesObject.rate = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Rate"].asString());
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Id"].isNull())
facesObject.id = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Id"].asString();
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Name"].isNull()) if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Name"].isNull())
facesObject.name = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Name"].asString(); facesObject.name = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Name"].asString();
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Id"].isNull())
facesObject.id = dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Id"].asString();
if(!dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Rate"].isNull())
facesObject.rate = std::stof(dataNodeResultsResultSubResultsSubResultSfaceDataListSfaceDataFacesFace["Rate"].asString());
sfaceDataListObject.faces.push_back(facesObject); sfaceDataListObject.faces.push_back(facesObject);
} }
subResultsObject.sfaceDataList.push_back(sfaceDataListObject); subResultsObject.sfaceDataList.push_back(sfaceDataListObject);
@@ -106,38 +96,48 @@ void ScanImageResult::parse(const std::string &payload)
hintWordsInfoListObject.context = dataNodeResultsResultSubResultsSubResultHintWordsInfoListHintWordsInfo["Context"].asString(); hintWordsInfoListObject.context = dataNodeResultsResultSubResultsSubResultHintWordsInfoListHintWordsInfo["Context"].asString();
subResultsObject.hintWordsInfoList.push_back(hintWordsInfoListObject); subResultsObject.hintWordsInfoList.push_back(hintWordsInfoListObject);
} }
auto allProgramCodeDataListNode = dataNodeResultsResultSubResultsSubResult["ProgramCodeDataList"]["ProgramCodeData"];
for (auto dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData : allProgramCodeDataListNode)
{
Data::Result::SubResult::ProgramCodeData programCodeDataListObject;
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Width"].isNull())
programCodeDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Width"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Height"].isNull())
programCodeDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Y"].isNull())
programCodeDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["X"].isNull())
programCodeDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["X"].asString());
subResultsObject.programCodeDataList.push_back(programCodeDataListObject);
}
auto allFramesNode = dataNodeResultsResultSubResultsSubResult["Frames"]["Frame"];
for (auto dataNodeResultsResultSubResultsSubResultFramesFrame : allFramesNode)
{
Data::Result::SubResult::Frame framesObject;
if(!dataNodeResultsResultSubResultsSubResultFramesFrame["URL"].isNull())
framesObject.uRL = dataNodeResultsResultSubResultsSubResultFramesFrame["URL"].asString();
if(!dataNodeResultsResultSubResultsSubResultFramesFrame["Rate"].isNull())
framesObject.rate = std::stof(dataNodeResultsResultSubResultsSubResultFramesFrame["Rate"].asString());
subResultsObject.frames.push_back(framesObject);
}
auto allLogoDataListNode = dataNodeResultsResultSubResultsSubResult["LogoDataList"]["LogoData"]; auto allLogoDataListNode = dataNodeResultsResultSubResultsSubResult["LogoDataList"]["LogoData"];
for (auto dataNodeResultsResultSubResultsSubResultLogoDataListLogoData : allLogoDataListNode) for (auto dataNodeResultsResultSubResultsSubResultLogoDataListLogoData : allLogoDataListNode)
{ {
Data::Result::SubResult::LogoData logoDataListObject; Data::Result::SubResult::LogoData logoDataListObject;
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Type"].isNull()) if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Type"].isNull())
logoDataListObject.type = dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Type"].asString(); logoDataListObject.type = dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Type"].asString();
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["X"].isNull())
logoDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["X"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Y"].isNull())
logoDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Height"].isNull())
logoDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Width"].isNull()) if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Width"].isNull())
logoDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Width"].asString()); logoDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Width"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Height"].isNull())
logoDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Y"].isNull())
logoDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Name"].isNull()) if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Name"].isNull())
logoDataListObject.name = dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Name"].asString(); logoDataListObject.name = dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["Name"].asString();
if(!dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["X"].isNull())
logoDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultLogoDataListLogoData["X"].asString());
subResultsObject.logoDataList.push_back(logoDataListObject); subResultsObject.logoDataList.push_back(logoDataListObject);
} }
auto allProgramCodeDataListNode = dataNodeResultsResultSubResultsSubResult["ProgramCodeDataList"]["ProgramCodeData"];
for (auto dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData : allProgramCodeDataListNode)
{
Data::Result::SubResult::ProgramCodeData programCodeDataListObject;
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["X"].isNull())
programCodeDataListObject.x = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["X"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Y"].isNull())
programCodeDataListObject.y = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Y"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Height"].isNull())
programCodeDataListObject.height = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Height"].asString());
if(!dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Width"].isNull())
programCodeDataListObject.width = std::stof(dataNodeResultsResultSubResultsSubResultProgramCodeDataListProgramCodeData["Width"].asString());
subResultsObject.programCodeDataList.push_back(programCodeDataListObject);
}
auto allOCRDataList = value["OCRDataList"]["OCRData"]; auto allOCRDataList = value["OCRDataList"]["OCRData"];
for (auto value : allOCRDataList) for (auto value : allOCRDataList)
subResultsObject.oCRDataList.push_back(value.asString()); subResultsObject.oCRDataList.push_back(value.asString());

74
imageaudit/src/model/ScanTextRequest.cc
View File

@@ -1,59 +1,53 @@
/* /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved. * Copyright 2009-2017 Alibaba Cloud All rights reserved.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include <alibabacloud/imageaudit/model/ScanTextRequest.h> #include <alibabacloud/imageaudit/model/ScanTextRequest.h>
using AlibabaCloud::Imageaudit::Model::ScanTextRequest; using AlibabaCloud::Imageaudit::Model::ScanTextRequest;
ScanTextRequest::ScanTextRequest() : ScanTextRequest::ScanTextRequest()
RpcServiceRequest("imageaudit", "2019-12-30", "ScanText") : RpcServiceRequest("imageaudit", "2019-12-30", "ScanText") {
{ setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::Post);
}
ScanTextRequest::~ScanTextRequest()
{}
std::vector<ScanTextRequest::Labels> ScanTextRequest::getLabels()const
{
return labels_;
} }
void ScanTextRequest::setLabels(const std::vector<Labels>& labels) ScanTextRequest::~ScanTextRequest() {}
{
labels_ = labels; std::vector<ScanTextRequest::Labels> ScanTextRequest::getLabels() const {
for(int dep1 = 0; dep1!= labels.size(); dep1++) { return labels_;
auto labelsObj = labels.at(dep1);
std::string labelsObjStr = "Labels." + std::to_string(dep1 + 1);
setParameter(labelsObjStr + ".Label", labelsObj.label);
}
} }
std::vector<ScanTextRequest::Tasks> ScanTextRequest::getTasks()const void ScanTextRequest::setLabels(const std::vector<ScanTextRequest::Labels> &labels) {
{ labels_ = labels;
return tasks_; for(int dep1 = 0; dep1 != labels.size(); dep1++) {
auto labelsObj = labels.at(dep1);
std::string labelsObjStr = std::string("Labels") + "." + std::to_string(dep1 + 1);
setBodyParameter(labelsObjStr + ".Label", labelsObj.label);
}
} }
void ScanTextRequest::setTasks(const std::vector<Tasks>& tasks) std::vector<ScanTextRequest::Tasks> ScanTextRequest::getTasks() const {
{ return tasks_;
tasks_ = tasks; }
for(int dep1 = 0; dep1!= tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1); void ScanTextRequest::setTasks(const std::vector<ScanTextRequest::Tasks> &tasks) {
std::string tasksObjStr = "Tasks." + std::to_string(dep1 + 1); tasks_ = tasks;
setParameter(tasksObjStr + ".Content", tasksObj.content); for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
} auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = std::string("Tasks") + "." + std::to_string(dep1 + 1);
setBodyParameter(tasksObjStr + ".Content", tasksObj.content);
}
} }

4
imageaudit/src/model/ScanTextResult.cc
View File

@@ -52,10 +52,10 @@ void ScanTextResult::parse(const std::string &payload)
Data::Element::Result resultsObject; Data::Element::Result resultsObject;
if(!dataNodeElementsElementResultsResult["Suggestion"].isNull()) if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString(); resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
if(!dataNodeElementsElementResultsResult["Label"].isNull()) if(!dataNodeElementsElementResultsResult["Label"].isNull())
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString(); resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
auto allDetailsNode = dataNodeElementsElementResultsResult["Details"]["Detail"]; auto allDetailsNode = dataNodeElementsElementResultsResult["Details"]["Detail"];
for (auto dataNodeElementsElementResultsResultDetailsDetail : allDetailsNode) for (auto dataNodeElementsElementResultsResultDetailsDetail : allDetailsNode)
{ {