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

Update sdk.

Browse Source
This commit is contained in:
sdk-team
2023-03-15 08:51:00 +00:00
parent 9a7ae6feb5
commit 45ae211126
8 changed files with 1 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1502
1.36.1503

4
imagerecog/CMakeLists.txt
View File

@@ -37,8 +37,6 @@ set(imagerecog_public_header_model
include/alibabacloud/imagerecog/model/RecognizeImageColorResult.h
include/alibabacloud/imagerecog/model/RecognizeImageStyleRequest.h
include/alibabacloud/imagerecog/model/RecognizeImageStyleResult.h
include/alibabacloud/imagerecog/model/RecognizeLogoRequest.h
include/alibabacloud/imagerecog/model/RecognizeLogoResult.h
include/alibabacloud/imagerecog/model/RecognizeSceneRequest.h
include/alibabacloud/imagerecog/model/RecognizeSceneResult.h
include/alibabacloud/imagerecog/model/RecognizeVehicleTypeRequest.h
@@ -66,8 +64,6 @@ set(imagerecog_src
src/model/RecognizeImageColorResult.cc
src/model/RecognizeImageStyleRequest.cc
src/model/RecognizeImageStyleResult.cc
src/model/RecognizeLogoRequest.cc
src/model/RecognizeLogoResult.cc
src/model/RecognizeSceneRequest.cc
src/model/RecognizeSceneResult.cc
src/model/RecognizeVehicleTypeRequest.cc

8
imagerecog/include/alibabacloud/imagerecog/ImagerecogClient.h
View File

@@ -38,8 +38,6 @@
#include "model/RecognizeImageColorResult.h"
#include "model/RecognizeImageStyleRequest.h"
#include "model/RecognizeImageStyleResult.h"
#include "model/RecognizeLogoRequest.h"
#include "model/RecognizeLogoResult.h"
#include "model/RecognizeSceneRequest.h"
#include "model/RecognizeSceneResult.h"
#include "model/RecognizeVehicleTypeRequest.h"
@@ -81,9 +79,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeImageStyleResult> RecognizeImageStyleOutcome;
typedef std::future<RecognizeImageStyleOutcome> RecognizeImageStyleOutcomeCallable;
typedef std::function<void(const ImagerecogClient*, const Model::RecognizeImageStyleRequest&, const RecognizeImageStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeImageStyleAsyncHandler;
typedef Outcome<Error, Model::RecognizeLogoResult> RecognizeLogoOutcome;
typedef std::future<RecognizeLogoOutcome> RecognizeLogoOutcomeCallable;
typedef std::function<void(const ImagerecogClient*, const Model::RecognizeLogoRequest&, const RecognizeLogoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeLogoAsyncHandler;
typedef Outcome<Error, Model::RecognizeSceneResult> RecognizeSceneOutcome;
typedef std::future<RecognizeSceneOutcome> RecognizeSceneOutcomeCallable;
typedef std::function<void(const ImagerecogClient*, const Model::RecognizeSceneRequest&, const RecognizeSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeSceneAsyncHandler;
@@ -125,9 +120,6 @@ namespace AlibabaCloud
RecognizeImageStyleOutcome recognizeImageStyle(const Model::RecognizeImageStyleRequest &request)const;
void recognizeImageStyleAsync(const Model::RecognizeImageStyleRequest& request, const RecognizeImageStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeImageStyleOutcomeCallable recognizeImageStyleCallable(const Model::RecognizeImageStyleRequest& request) const;
RecognizeLogoOutcome recognizeLogo(const Model::RecognizeLogoRequest &request)const;
void recognizeLogoAsync(const Model::RecognizeLogoRequest& request, const RecognizeLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeLogoOutcomeCallable recognizeLogoCallable(const Model::RecognizeLogoRequest& request) const;
RecognizeSceneOutcome recognizeScene(const Model::RecognizeSceneRequest &request)const;
void recognizeSceneAsync(const Model::RecognizeSceneRequest& request, const RecognizeSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeSceneOutcomeCallable recognizeSceneCallable(const Model::RecognizeSceneRequest& request) const;

54
imagerecog/include/alibabacloud/imagerecog/model/RecognizeLogoRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGOREQUEST_H_
#define ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGOREQUEST_H_
#include <alibabacloud/imagerecog/ImagerecogExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imagerecog {
namespace Model {
class ALIBABACLOUD_IMAGERECOG_EXPORT RecognizeLogoRequest : public RpcServiceRequest {
public:
struct Tasks {
std::string imageURL;
};
RecognizeLogoRequest();
~RecognizeLogoRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::vector<Tasks> getTasks() const;
void setTasks(const std::vector<Tasks> &tasks);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
private:
bool formatResultToJson_;
std::string ossFile_;
std::vector<Tasks> tasks_;
std::string requestProxyBy_;
};
} // namespace Model
} // namespace Imagerecog
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGOREQUEST_H_

77
imagerecog/include/alibabacloud/imagerecog/model/RecognizeLogoResult.h
View File

@@ -1,77 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGORESULT_H_
#define ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imagerecog/ImagerecogExport.h>
namespace AlibabaCloud
{
namespace Imagerecog
{
namespace Model
{
class ALIBABACLOUD_IMAGERECOG_EXPORT RecognizeLogoResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct Result
{
struct LogoData
{
std::string type;
float w;
float h;
float x;
float y;
std::string name;
};
std::string suggestion;
std::vector<Result::LogoData> logosData;
float rate;
std::string label;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
};
std::vector<Element> elements;
};
RecognizeLogoResult();
explicit RecognizeLogoResult(const std::string &payload);
~RecognizeLogoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGERECOG_MODEL_RECOGNIZELOGORESULT_H_

36
imagerecog/src/ImagerecogClient.cc
View File

@@ -339,42 +339,6 @@ ImagerecogClient::RecognizeImageStyleOutcomeCallable ImagerecogClient::recognize
return task->get_future();
}
ImagerecogClient::RecognizeLogoOutcome ImagerecogClient::recognizeLogo(const RecognizeLogoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeLogoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeLogoOutcome(RecognizeLogoResult(outcome.result()));
else
return RecognizeLogoOutcome(outcome.error());
}
void ImagerecogClient::recognizeLogoAsync(const RecognizeLogoRequest& request, const RecognizeLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeLogo(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagerecogClient::RecognizeLogoOutcomeCallable ImagerecogClient::recognizeLogoCallable(const RecognizeLogoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeLogoOutcome()>>(
[this, request]()
{
return this->recognizeLogo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagerecogClient::RecognizeSceneOutcome ImagerecogClient::recognizeScene(const RecognizeSceneRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

67
imagerecog/src/model/RecognizeLogoRequest.cc
View File

@@ -1,67 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imagerecog/model/RecognizeLogoRequest.h>
using AlibabaCloud::Imagerecog::Model::RecognizeLogoRequest;
RecognizeLogoRequest::RecognizeLogoRequest()
: RpcServiceRequest("imagerecog", "2019-09-30", "RecognizeLogo") {
setMethod(HttpRequest::Method::Post);
}
RecognizeLogoRequest::~RecognizeLogoRequest() {}
bool RecognizeLogoRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void RecognizeLogoRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string RecognizeLogoRequest::getOssFile() const {
return ossFile_;
}
void RecognizeLogoRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::vector<RecognizeLogoRequest::Tasks> RecognizeLogoRequest::getTasks() const {
return tasks_;
}
void RecognizeLogoRequest::setTasks(const std::vector<RecognizeLogoRequest::Tasks> &tasks) {
tasks_ = tasks;
for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = std::string("Tasks") + "." + std::to_string(dep1 + 1);
setBodyParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}
std::string RecognizeLogoRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void RecognizeLogoRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}

90
imagerecog/src/model/RecognizeLogoResult.cc
View File

@@ -1,90 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imagerecog/model/RecognizeLogoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imagerecog;
using namespace AlibabaCloud::Imagerecog::Model;
RecognizeLogoResult::RecognizeLogoResult() :
ServiceResult()
{}
RecognizeLogoResult::RecognizeLogoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeLogoResult::~RecognizeLogoResult()
{}
void RecognizeLogoResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["TaskId"].isNull())
elementObject.taskId = dataNodeElementsElement["TaskId"].asString();
auto allResultsNode = dataNodeElementsElement["Results"]["Result"];
for (auto dataNodeElementsElementResultsResult : allResultsNode)
{
Data::Element::Result resultsObject;
if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
if(!dataNodeElementsElementResultsResult["Label"].isNull())
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
auto allLogosDataNode = dataNodeElementsElementResultsResult["LogosData"]["LogoData"];
for (auto dataNodeElementsElementResultsResultLogosDataLogoData : allLogosDataNode)
{
Data::Element::Result::LogoData logosDataObject;
if(!dataNodeElementsElementResultsResultLogosDataLogoData["Type"].isNull())
logosDataObject.type = dataNodeElementsElementResultsResultLogosDataLogoData["Type"].asString();
if(!dataNodeElementsElementResultsResultLogosDataLogoData["W"].isNull())
logosDataObject.w = std::stof(dataNodeElementsElementResultsResultLogosDataLogoData["W"].asString());
if(!dataNodeElementsElementResultsResultLogosDataLogoData["H"].isNull())
logosDataObject.h = std::stof(dataNodeElementsElementResultsResultLogosDataLogoData["H"].asString());
if(!dataNodeElementsElementResultsResultLogosDataLogoData["Y"].isNull())
logosDataObject.y = std::stof(dataNodeElementsElementResultsResultLogosDataLogoData["Y"].asString());
if(!dataNodeElementsElementResultsResultLogosDataLogoData["Name"].isNull())
logosDataObject.name = dataNodeElementsElementResultsResultLogosDataLogoData["Name"].asString();
if(!dataNodeElementsElementResultsResultLogosDataLogoData["X"].isNull())
logosDataObject.x = std::stof(dataNodeElementsElementResultsResultLogosDataLogoData["X"].asString());
resultsObject.logosData.push_back(logosDataObject);
}
elementObject.results.push_back(resultsObject);
}
data_.elements.push_back(elementObject);
}
}
RecognizeLogoResult::Data RecognizeLogoResult::getData()const
{
return data_;
}