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.
*/
#include <alibabacloud/facebody/model/AddFaceRequest.h>
using AlibabaCloud::Facebody::Model::AddFaceRequest;
AddFaceRequest::AddFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "AddFace")
{
setMethod(HttpRequest::Method::Post);
}
AddFaceRequest::~AddFaceRequest()
{}
std::string AddFaceRequest::getEntityId()const
{
return entityId_;
}
void AddFaceRequest::setEntityId(const std::string& entityId)
{
entityId_ = entityId;
setBodyParameter("EntityId", entityId);
}
std::string AddFaceRequest::getDbName()const
{
return dbName_;
}
void AddFaceRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
std::string AddFaceRequest::getImageUrl()const
{
return imageUrl_;
}
void AddFaceRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
std::string AddFaceRequest::getExtraData()const
{
return extraData_;
}
void AddFaceRequest::setExtraData(const std::string& extraData)
{
extraData_ = extraData;
setBodyParameter("ExtraData", extraData);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/AddFaceRequest.cc
|
C++
|
apache-2.0
| 1,758
|
/*
* 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/facebody/model/AddFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
AddFaceResult::AddFaceResult() :
ServiceResult()
{}
AddFaceResult::AddFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddFaceResult::~AddFaceResult()
{}
void AddFaceResult::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["FaceId"].isNull())
data_.faceId = dataNode["FaceId"].asString();
}
AddFaceResult::Data AddFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/AddFaceResult.cc
|
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.
*/
#include <alibabacloud/facebody/model/BlurFaceRequest.h>
using AlibabaCloud::Facebody::Model::BlurFaceRequest;
BlurFaceRequest::BlurFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "BlurFace")
{
setMethod(HttpRequest::Method::Post);
}
BlurFaceRequest::~BlurFaceRequest()
{}
std::string BlurFaceRequest::getImageURL()const
{
return imageURL_;
}
void BlurFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/BlurFaceRequest.cc
|
C++
|
apache-2.0
| 1,136
|
/*
* 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/facebody/model/BlurFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
BlurFaceResult::BlurFaceResult() :
ServiceResult()
{}
BlurFaceResult::BlurFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BlurFaceResult::~BlurFaceResult()
{}
void BlurFaceResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
BlurFaceResult::Data BlurFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/BlurFaceResult.cc
|
C++
|
apache-2.0
| 1,362
|
/*
* 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/facebody/model/BodyPostureRequest.h>
using AlibabaCloud::Facebody::Model::BodyPostureRequest;
BodyPostureRequest::BodyPostureRequest() :
RpcServiceRequest("facebody", "2019-12-30", "BodyPosture")
{
setMethod(HttpRequest::Method::Post);
}
BodyPostureRequest::~BodyPostureRequest()
{}
std::string BodyPostureRequest::getImageURL()const
{
return imageURL_;
}
void BodyPostureRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/BodyPostureRequest.cc
|
C++
|
apache-2.0
| 1,163
|
/*
* 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/facebody/model/BodyPostureResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
BodyPostureResult::BodyPostureResult() :
ServiceResult()
{}
BodyPostureResult::BodyPostureResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BodyPostureResult::~BodyPostureResult()
{}
void BodyPostureResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allOutputsNode = dataNode["Outputs"]["Output"];
for (auto dataNodeOutputsOutput : allOutputsNode)
{
Data::Output outputObject;
if(!dataNodeOutputsOutput["HumanCount"].isNull())
outputObject.humanCount = std::stoi(dataNodeOutputsOutput["HumanCount"].asString());
auto allResultsNode = dataNodeOutputsOutput["Results"]["Result"];
for (auto dataNodeOutputsOutputResultsResult : allResultsNode)
{
Data::Output::Result resultsObject;
auto allBodiesNode = dataNodeOutputsOutputResultsResult["Bodies"]["Body"];
for (auto dataNodeOutputsOutputResultsResultBodiesBody : allBodiesNode)
{
Data::Output::Result::Body bodiesObject;
if(!dataNodeOutputsOutputResultsResultBodiesBody["Confident"].isNull())
bodiesObject.confident = std::stof(dataNodeOutputsOutputResultsResultBodiesBody["Confident"].asString());
if(!dataNodeOutputsOutputResultsResultBodiesBody["Label"].isNull())
bodiesObject.label = dataNodeOutputsOutputResultsResultBodiesBody["Label"].asString();
auto allPositionsNode = dataNodeOutputsOutputResultsResultBodiesBody["Positions"]["Position"];
for (auto dataNodeOutputsOutputResultsResultBodiesBodyPositionsPosition : allPositionsNode)
{
Data::Output::Result::Body::Position positionsObject;
auto allPoints = value["Points"]["Point"];
for (auto value : allPoints)
positionsObject.points.push_back(value.asString());
bodiesObject.positions.push_back(positionsObject);
}
resultsObject.bodies.push_back(bodiesObject);
}
outputObject.results.push_back(resultsObject);
}
data_.outputs.push_back(outputObject);
}
auto metaObjectNode = dataNode["MetaObject"];
if(!metaObjectNode["Height"].isNull())
data_.metaObject.height = std::stoi(metaObjectNode["Height"].asString());
if(!metaObjectNode["Width"].isNull())
data_.metaObject.width = std::stoi(metaObjectNode["Width"].asString());
}
BodyPostureResult::Data BodyPostureResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/BodyPostureResult.cc
|
C++
|
apache-2.0
| 3,202
|
/*
* 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/facebody/model/CompareFaceRequest.h>
using AlibabaCloud::Facebody::Model::CompareFaceRequest;
CompareFaceRequest::CompareFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "CompareFace")
{
setMethod(HttpRequest::Method::Post);
}
CompareFaceRequest::~CompareFaceRequest()
{}
int CompareFaceRequest::getImageType()const
{
return imageType_;
}
void CompareFaceRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string CompareFaceRequest::getImageURLB()const
{
return imageURLB_;
}
void CompareFaceRequest::setImageURLB(const std::string& imageURLB)
{
imageURLB_ = imageURLB;
setBodyParameter("ImageURLB", imageURLB);
}
std::string CompareFaceRequest::getImageURLA()const
{
return imageURLA_;
}
void CompareFaceRequest::setImageURLA(const std::string& imageURLA)
{
imageURLA_ = imageURLA;
setBodyParameter("ImageURLA", imageURLA);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CompareFaceRequest.cc
|
C++
|
apache-2.0
| 1,622
|
/*
* 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/facebody/model/CompareFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
CompareFaceResult::CompareFaceResult() :
ServiceResult()
{}
CompareFaceResult::CompareFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CompareFaceResult::~CompareFaceResult()
{}
void CompareFaceResult::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["Confidence"].isNull())
data_.confidence = std::stof(dataNode["Confidence"].asString());
auto allThresholds = dataNode["Thresholds"];
for (auto value : allThresholds)
data_.thresholds.push_back(value.asDouble());
auto allRectAList = dataNode["RectAList"];
for (auto value : allRectAList)
data_.rectAList.push_back(value.asDouble());
auto allRectBList = dataNode["RectBList"];
for (auto value : allRectBList)
data_.rectBList.push_back(value.asDouble());
}
CompareFaceResult::Data CompareFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CompareFaceResult.cc
|
C++
|
apache-2.0
| 1,794
|
/*
* 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/facebody/model/CountCrowdRequest.h>
using AlibabaCloud::Facebody::Model::CountCrowdRequest;
CountCrowdRequest::CountCrowdRequest() :
RpcServiceRequest("facebody", "2019-12-30", "CountCrowd")
{
setMethod(HttpRequest::Method::Post);
}
CountCrowdRequest::~CountCrowdRequest()
{}
bool CountCrowdRequest::getIsShow()const
{
return isShow_;
}
void CountCrowdRequest::setIsShow(bool isShow)
{
isShow_ = isShow;
setBodyParameter("IsShow", isShow ? "true" : "false");
}
std::string CountCrowdRequest::getImageURL()const
{
return imageURL_;
}
void CountCrowdRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CountCrowdRequest.cc
|
C++
|
apache-2.0
| 1,355
|
/*
* 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/facebody/model/CountCrowdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
CountCrowdResult::CountCrowdResult() :
ServiceResult()
{}
CountCrowdResult::CountCrowdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CountCrowdResult::~CountCrowdResult()
{}
void CountCrowdResult::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["PeopleNumber"].isNull())
data_.peopleNumber = std::stoi(dataNode["PeopleNumber"].asString());
if(!dataNode["HotMap"].isNull())
data_.hotMap = dataNode["HotMap"].asString();
}
CountCrowdResult::Data CountCrowdResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CountCrowdResult.cc
|
C++
|
apache-2.0
| 1,487
|
/*
* 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/facebody/model/CreateFaceDbRequest.h>
using AlibabaCloud::Facebody::Model::CreateFaceDbRequest;
CreateFaceDbRequest::CreateFaceDbRequest() :
RpcServiceRequest("facebody", "2019-12-30", "CreateFaceDb")
{
setMethod(HttpRequest::Method::Post);
}
CreateFaceDbRequest::~CreateFaceDbRequest()
{}
std::string CreateFaceDbRequest::getName()const
{
return name_;
}
void CreateFaceDbRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CreateFaceDbRequest.cc
|
C++
|
apache-2.0
| 1,140
|
/*
* 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/facebody/model/CreateFaceDbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
CreateFaceDbResult::CreateFaceDbResult() :
ServiceResult()
{}
CreateFaceDbResult::CreateFaceDbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateFaceDbResult::~CreateFaceDbResult()
{}
void CreateFaceDbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/CreateFaceDbResult.cc
|
C++
|
apache-2.0
| 1,202
|
/*
* 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/facebody/model/DeleteFaceDbRequest.h>
using AlibabaCloud::Facebody::Model::DeleteFaceDbRequest;
DeleteFaceDbRequest::DeleteFaceDbRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DeleteFaceDb")
{
setMethod(HttpRequest::Method::Post);
}
DeleteFaceDbRequest::~DeleteFaceDbRequest()
{}
std::string DeleteFaceDbRequest::getName()const
{
return name_;
}
void DeleteFaceDbRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceDbRequest.cc
|
C++
|
apache-2.0
| 1,140
|
/*
* 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/facebody/model/DeleteFaceDbResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeleteFaceDbResult::DeleteFaceDbResult() :
ServiceResult()
{}
DeleteFaceDbResult::DeleteFaceDbResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteFaceDbResult::~DeleteFaceDbResult()
{}
void DeleteFaceDbResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceDbResult.cc
|
C++
|
apache-2.0
| 1,202
|
/*
* 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/facebody/model/DeleteFaceEntityRequest.h>
using AlibabaCloud::Facebody::Model::DeleteFaceEntityRequest;
DeleteFaceEntityRequest::DeleteFaceEntityRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DeleteFaceEntity")
{
setMethod(HttpRequest::Method::Post);
}
DeleteFaceEntityRequest::~DeleteFaceEntityRequest()
{}
std::string DeleteFaceEntityRequest::getEntityId()const
{
return entityId_;
}
void DeleteFaceEntityRequest::setEntityId(const std::string& entityId)
{
entityId_ = entityId;
setBodyParameter("EntityId", entityId);
}
std::string DeleteFaceEntityRequest::getDbName()const
{
return dbName_;
}
void DeleteFaceEntityRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceEntityRequest.cc
|
C++
|
apache-2.0
| 1,423
|
/*
* 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/facebody/model/DeleteFaceEntityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeleteFaceEntityResult::DeleteFaceEntityResult() :
ServiceResult()
{}
DeleteFaceEntityResult::DeleteFaceEntityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteFaceEntityResult::~DeleteFaceEntityResult()
{}
void DeleteFaceEntityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceEntityResult.cc
|
C++
|
apache-2.0
| 1,234
|
/*
* 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/facebody/model/DeleteFaceRequest.h>
using AlibabaCloud::Facebody::Model::DeleteFaceRequest;
DeleteFaceRequest::DeleteFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DeleteFace")
{
setMethod(HttpRequest::Method::Post);
}
DeleteFaceRequest::~DeleteFaceRequest()
{}
std::string DeleteFaceRequest::getFaceId()const
{
return faceId_;
}
void DeleteFaceRequest::setFaceId(const std::string& faceId)
{
faceId_ = faceId;
setBodyParameter("FaceId", faceId);
}
std::string DeleteFaceRequest::getDbName()const
{
return dbName_;
}
void DeleteFaceRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceRequest.cc
|
C++
|
apache-2.0
| 1,341
|
/*
* 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/facebody/model/DeleteFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeleteFaceResult::DeleteFaceResult() :
ServiceResult()
{}
DeleteFaceResult::DeleteFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteFaceResult::~DeleteFaceResult()
{}
void DeleteFaceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DeleteFaceResult.cc
|
C++
|
apache-2.0
| 1,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.
*/
#include <alibabacloud/facebody/model/DetectBodyCountRequest.h>
using AlibabaCloud::Facebody::Model::DetectBodyCountRequest;
DetectBodyCountRequest::DetectBodyCountRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectBodyCount")
{
setMethod(HttpRequest::Method::Post);
}
DetectBodyCountRequest::~DetectBodyCountRequest()
{}
std::string DetectBodyCountRequest::getImageURL()const
{
return imageURL_;
}
void DetectBodyCountRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectBodyCountRequest.cc
|
C++
|
apache-2.0
| 1,199
|
/*
* 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/facebody/model/DetectBodyCountResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectBodyCountResult::DetectBodyCountResult() :
ServiceResult()
{}
DetectBodyCountResult::DetectBodyCountResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectBodyCountResult::~DetectBodyCountResult()
{}
void DetectBodyCountResult::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["PersonNumber"].isNull())
data_.personNumber = std::stoi(dataNode["PersonNumber"].asString());
}
DetectBodyCountResult::Data DetectBodyCountResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectBodyCountResult.cc
|
C++
|
apache-2.0
| 1,455
|
/*
* 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/facebody/model/DetectCelebrityRequest.h>
using AlibabaCloud::Facebody::Model::DetectCelebrityRequest;
DetectCelebrityRequest::DetectCelebrityRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectCelebrity")
{
setMethod(HttpRequest::Method::Post);
}
DetectCelebrityRequest::~DetectCelebrityRequest()
{}
std::string DetectCelebrityRequest::getImageURL()const
{
return imageURL_;
}
void DetectCelebrityRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectCelebrityRequest.cc
|
C++
|
apache-2.0
| 1,199
|
/*
* 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/facebody/model/DetectCelebrityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectCelebrityResult::DetectCelebrityResult() :
ServiceResult()
{}
DetectCelebrityResult::DetectCelebrityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectCelebrityResult::~DetectCelebrityResult()
{}
void DetectCelebrityResult::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 allFaceRecognizeResultsNode = dataNode["FaceRecognizeResults"]["FaceRecognizeResult"];
for (auto dataNodeFaceRecognizeResultsFaceRecognizeResult : allFaceRecognizeResultsNode)
{
Data::FaceRecognizeResult faceRecognizeResultObject;
if(!dataNodeFaceRecognizeResultsFaceRecognizeResult["Name"].isNull())
faceRecognizeResultObject.name = dataNodeFaceRecognizeResultsFaceRecognizeResult["Name"].asString();
auto allFaceBoxes = value["FaceBoxes"]["FaceBox"];
for (auto value : allFaceBoxes)
faceRecognizeResultObject.faceBoxes.push_back(value.asString());
data_.faceRecognizeResults.push_back(faceRecognizeResultObject);
}
}
DetectCelebrityResult::Data DetectCelebrityResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectCelebrityResult.cc
|
C++
|
apache-2.0
| 2,169
|
/*
* 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/facebody/model/DetectChefCapRequest.h>
using AlibabaCloud::Facebody::Model::DetectChefCapRequest;
DetectChefCapRequest::DetectChefCapRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectChefCap")
{
setMethod(HttpRequest::Method::Post);
}
DetectChefCapRequest::~DetectChefCapRequest()
{}
std::string DetectChefCapRequest::getImageURL()const
{
return imageURL_;
}
void DetectChefCapRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectChefCapRequest.cc
|
C++
|
apache-2.0
| 1,181
|
/*
* 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/facebody/model/DetectChefCapResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectChefCapResult::DetectChefCapResult() :
ServiceResult()
{}
DetectChefCapResult::DetectChefCapResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectChefCapResult::~DetectChefCapResult()
{}
void DetectChefCapResult::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"]["ElementsItem"];
for (auto dataNodeElementsElementsItem : allElementsNode)
{
Data::ElementsItem elementsItemObject;
if(!dataNodeElementsElementsItem["Category"].isNull())
elementsItemObject.category = dataNodeElementsElementsItem["Category"].asString();
if(!dataNodeElementsElementsItem["Confidence"].isNull())
elementsItemObject.confidence = std::stof(dataNodeElementsElementsItem["Confidence"].asString());
auto allBox = value["Box"]["Box"];
for (auto value : allBox)
elementsItemObject.box.push_back(value.asString());
data_.elements.push_back(elementsItemObject);
}
}
DetectChefCapResult::Data DetectChefCapResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectChefCapResult.cc
|
C++
|
apache-2.0
| 1,963
|
/*
* 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/facebody/model/DetectFaceRequest.h>
using AlibabaCloud::Facebody::Model::DetectFaceRequest;
DetectFaceRequest::DetectFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectFace")
{
setMethod(HttpRequest::Method::Post);
}
DetectFaceRequest::~DetectFaceRequest()
{}
int DetectFaceRequest::getImageType()const
{
return imageType_;
}
void DetectFaceRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string DetectFaceRequest::getImageURL()const
{
return imageURL_;
}
void DetectFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectFaceRequest.cc
|
C++
|
apache-2.0
| 1,374
|
/*
* 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/facebody/model/DetectFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectFaceResult::DetectFaceResult() :
ServiceResult()
{}
DetectFaceResult::DetectFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectFaceResult::~DetectFaceResult()
{}
void DetectFaceResult::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["LandmarkCount"].isNull())
data_.landmarkCount = std::stoi(dataNode["LandmarkCount"].asString());
if(!dataNode["FaceCount"].isNull())
data_.faceCount = std::stoi(dataNode["FaceCount"].asString());
auto qualitiesNode = dataNode["Qualities"];
auto allNoiseList = qualitiesNode["NoiseList"]["Noise"];
for (auto value : allNoiseList)
data_.qualities.noiseList.push_back(value.asString());
auto allScoreList = qualitiesNode["ScoreList"]["Score"];
for (auto value : allScoreList)
data_.qualities.scoreList.push_back(value.asString());
auto allBlurList = qualitiesNode["BlurList"]["Blur"];
for (auto value : allBlurList)
data_.qualities.blurList.push_back(value.asString());
auto allMaskList = qualitiesNode["MaskList"]["Mask"];
for (auto value : allMaskList)
data_.qualities.maskList.push_back(value.asString());
auto allGlassList = qualitiesNode["GlassList"]["Glass"];
for (auto value : allGlassList)
data_.qualities.glassList.push_back(value.asString());
auto allFnfList = qualitiesNode["FnfList"]["Fnf"];
for (auto value : allFnfList)
data_.qualities.fnfList.push_back(value.asString());
auto allPoseList1 = qualitiesNode["PoseList"]["Pose"];
for (auto value : allPoseList1)
data_.qualities.poseList1.push_back(value.asString());
auto allIlluList = qualitiesNode["IlluList"]["Illu"];
for (auto value : allIlluList)
data_.qualities.illuList.push_back(value.asString());
auto allFaceProbabilityList = dataNode["FaceProbabilityList"]["FaceProbability"];
for (auto value : allFaceProbabilityList)
data_.faceProbabilityList.push_back(value.asString());
auto allFaceRectangles = dataNode["FaceRectangles"]["FaceRectangle"];
for (auto value : allFaceRectangles)
data_.faceRectangles.push_back(value.asString());
auto allLandmarks = dataNode["Landmarks"]["Landmark"];
for (auto value : allLandmarks)
data_.landmarks.push_back(value.asString());
auto allPoseList = dataNode["PoseList"]["Pose"];
for (auto value : allPoseList)
data_.poseList.push_back(value.asString());
auto allPupils = dataNode["Pupils"]["Pupil"];
for (auto value : allPupils)
data_.pupils.push_back(value.asString());
}
DetectFaceResult::Data DetectFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectFaceResult.cc
|
C++
|
apache-2.0
| 3,480
|
/*
* 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/facebody/model/DetectIPCPedestrianRequest.h>
using AlibabaCloud::Facebody::Model::DetectIPCPedestrianRequest;
DetectIPCPedestrianRequest::DetectIPCPedestrianRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectIPCPedestrian")
{
setMethod(HttpRequest::Method::Post);
}
DetectIPCPedestrianRequest::~DetectIPCPedestrianRequest()
{}
std::string DetectIPCPedestrianRequest::getImageData()const
{
return imageData_;
}
void DetectIPCPedestrianRequest::setImageData(const std::string& imageData)
{
imageData_ = imageData;
setBodyParameter("ImageData", imageData);
}
std::vector<DetectIPCPedestrianRequest::URLList> DetectIPCPedestrianRequest::getURLList()const
{
return uRLList_;
}
void DetectIPCPedestrianRequest::setURLList(const std::vector<URLList>& uRLList)
{
uRLList_ = uRLList;
for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
auto uRLListObj = uRLList.at(dep1);
std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
setParameter(uRLListObjStr + ".DataId", uRLListObj.dataId);
setParameter(uRLListObjStr + ".ImageURL", uRLListObj.imageURL);
}
}
bool DetectIPCPedestrianRequest::getContinueOnError()const
{
return continueOnError_;
}
void DetectIPCPedestrianRequest::setContinueOnError(bool continueOnError)
{
continueOnError_ = continueOnError;
setBodyParameter("ContinueOnError", continueOnError ? "true" : "false");
}
int DetectIPCPedestrianRequest::getWidth()const
{
return width_;
}
void DetectIPCPedestrianRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
}
int DetectIPCPedestrianRequest::getHeight()const
{
return height_;
}
void DetectIPCPedestrianRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectIPCPedestrianRequest.cc
|
C++
|
apache-2.0
| 2,484
|
/*
* 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/facebody/model/DetectIPCPedestrianResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectIPCPedestrianResult::DetectIPCPedestrianResult() :
ServiceResult()
{}
DetectIPCPedestrianResult::DetectIPCPedestrianResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectIPCPedestrianResult::~DetectIPCPedestrianResult()
{}
void DetectIPCPedestrianResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allImageInfoListNode = dataNode["ImageInfoList"]["ImageInfoListItem"];
for (auto dataNodeImageInfoListImageInfoListItem : allImageInfoListNode)
{
Data::ImageInfoListItem imageInfoListItemObject;
if(!dataNodeImageInfoListImageInfoListItem["ErrorCode"].isNull())
imageInfoListItemObject.errorCode = dataNodeImageInfoListImageInfoListItem["ErrorCode"].asString();
if(!dataNodeImageInfoListImageInfoListItem["ErrorMessage"].isNull())
imageInfoListItemObject.errorMessage = dataNodeImageInfoListImageInfoListItem["ErrorMessage"].asString();
if(!dataNodeImageInfoListImageInfoListItem["DataId"].isNull())
imageInfoListItemObject.dataId = dataNodeImageInfoListImageInfoListItem["DataId"].asString();
auto allElementsNode = dataNodeImageInfoListImageInfoListItem["Elements"]["Element"];
for (auto dataNodeImageInfoListImageInfoListItemElementsElement : allElementsNode)
{
Data::ImageInfoListItem::Element elementsObject;
if(!dataNodeImageInfoListImageInfoListItemElementsElement["Score"].isNull())
elementsObject.score = std::stof(dataNodeImageInfoListImageInfoListItemElementsElement["Score"].asString());
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
elementsObject.boxes.push_back(value.asString());
imageInfoListItemObject.elements.push_back(elementsObject);
}
data_.imageInfoList.push_back(imageInfoListItemObject);
}
}
DetectIPCPedestrianResult::Data DetectIPCPedestrianResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectIPCPedestrianResult.cc
|
C++
|
apache-2.0
| 2,779
|
/*
* 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/facebody/model/DetectLivingFaceRequest.h>
using AlibabaCloud::Facebody::Model::DetectLivingFaceRequest;
DetectLivingFaceRequest::DetectLivingFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectLivingFace")
{
setMethod(HttpRequest::Method::Post);
}
DetectLivingFaceRequest::~DetectLivingFaceRequest()
{}
std::vector<DetectLivingFaceRequest::Tasks> DetectLivingFaceRequest::getTasks()const
{
return tasks_;
}
void DetectLivingFaceRequest::setTasks(const std::vector<Tasks>& tasks)
{
tasks_ = tasks;
for(int dep1 = 0; dep1!= tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = "Tasks." + std::to_string(dep1 + 1);
setParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectLivingFaceRequest.cc
|
C++
|
apache-2.0
| 1,405
|
/*
* 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/facebody/model/DetectLivingFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectLivingFaceResult::DetectLivingFaceResult() :
ServiceResult()
{}
DetectLivingFaceResult::DetectLivingFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectLivingFaceResult::~DetectLivingFaceResult()
{}
void DetectLivingFaceResult::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["TaskId"].isNull())
elementObject.taskId = dataNodeElementsElement["TaskId"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
auto allResultsNode = dataNodeElementsElement["Results"]["Result"];
for (auto dataNodeElementsElementResultsResult : allResultsNode)
{
Data::Element::Result resultsObject;
if(!dataNodeElementsElementResultsResult["Label"].isNull())
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
auto allFramesNode = dataNodeElementsElementResultsResult["Frames"]["Frame"];
for (auto dataNodeElementsElementResultsResultFramesFrame : allFramesNode)
{
Data::Element::Result::Frame framesObject;
if(!dataNodeElementsElementResultsResultFramesFrame["Rate"].isNull())
framesObject.rate = std::stof(dataNodeElementsElementResultsResultFramesFrame["Rate"].asString());
if(!dataNodeElementsElementResultsResultFramesFrame["Url"].isNull())
framesObject.url = dataNodeElementsElementResultsResultFramesFrame["Url"].asString();
resultsObject.frames.push_back(framesObject);
}
elementObject.results.push_back(resultsObject);
}
data_.elements.push_back(elementObject);
}
}
DetectLivingFaceResult::Data DetectLivingFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectLivingFaceResult.cc
|
C++
|
apache-2.0
| 3,103
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/facebody/model/DetectMaskRequest.h>
using AlibabaCloud::Facebody::Model::DetectMaskRequest;
DetectMaskRequest::DetectMaskRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectMask")
{
setMethod(HttpRequest::Method::Post);
}
DetectMaskRequest::~DetectMaskRequest()
{}
std::string DetectMaskRequest::getImageURL()const
{
return imageURL_;
}
void DetectMaskRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectMaskRequest.cc
|
C++
|
apache-2.0
| 1,154
|
/*
* 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/facebody/model/DetectMaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectMaskResult::DetectMaskResult() :
ServiceResult()
{}
DetectMaskResult::DetectMaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectMaskResult::~DetectMaskResult()
{}
void DetectMaskResult::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["Mask"].isNull())
data_.mask = std::stoi(dataNode["Mask"].asString());
if(!dataNode["FaceProbability"].isNull())
data_.faceProbability = std::stof(dataNode["FaceProbability"].asString());
}
DetectMaskResult::Data DetectMaskResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectMaskResult.cc
|
C++
|
apache-2.0
| 1,501
|
/*
* 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/facebody/model/DetectPedestrianRequest.h>
using AlibabaCloud::Facebody::Model::DetectPedestrianRequest;
DetectPedestrianRequest::DetectPedestrianRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectPedestrian")
{
setMethod(HttpRequest::Method::Post);
}
DetectPedestrianRequest::~DetectPedestrianRequest()
{}
std::string DetectPedestrianRequest::getImageURL()const
{
return imageURL_;
}
void DetectPedestrianRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectPedestrianRequest.cc
|
C++
|
apache-2.0
| 1,208
|
/*
* 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/facebody/model/DetectPedestrianResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectPedestrianResult::DetectPedestrianResult() :
ServiceResult()
{}
DetectPedestrianResult::DetectPedestrianResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectPedestrianResult::~DetectPedestrianResult()
{}
void DetectPedestrianResult::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["Height"].isNull())
data_.height = std::stoi(dataNode["Height"].asString());
if(!dataNode["Width"].isNull())
data_.width = std::stoi(dataNode["Width"].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.asString());
data_.elements.push_back(elementObject);
}
}
DetectPedestrianResult::Data DetectPedestrianResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectPedestrianResult.cc
|
C++
|
apache-2.0
| 2,097
|
/*
* 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/facebody/model/DetectVideoLivingFaceRequest.h>
using AlibabaCloud::Facebody::Model::DetectVideoLivingFaceRequest;
DetectVideoLivingFaceRequest::DetectVideoLivingFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "DetectVideoLivingFace")
{
setMethod(HttpRequest::Method::Post);
}
DetectVideoLivingFaceRequest::~DetectVideoLivingFaceRequest()
{}
std::string DetectVideoLivingFaceRequest::getVideoUrl()const
{
return videoUrl_;
}
void DetectVideoLivingFaceRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectVideoLivingFaceRequest.cc
|
C++
|
apache-2.0
| 1,253
|
/*
* 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/facebody/model/DetectVideoLivingFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DetectVideoLivingFaceResult::DetectVideoLivingFaceResult() :
ServiceResult()
{}
DetectVideoLivingFaceResult::DetectVideoLivingFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectVideoLivingFaceResult::~DetectVideoLivingFaceResult()
{}
void DetectVideoLivingFaceResult::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["LiveConfidence"].isNull())
elementObject.liveConfidence = std::stof(dataNodeElementsElement["LiveConfidence"].asString());
if(!dataNodeElementsElement["FaceConfidence"].isNull())
elementObject.faceConfidence = std::stof(dataNodeElementsElement["FaceConfidence"].asString());
auto allRect = value["Rect"]["Result"];
for (auto value : allRect)
elementObject.rect.push_back(value.asString());
data_.elements.push_back(elementObject);
}
}
DetectVideoLivingFaceResult::Data DetectVideoLivingFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/DetectVideoLivingFaceResult.cc
|
C++
|
apache-2.0
| 2,031
|
/*
* 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/facebody/model/EnhanceFaceRequest.h>
using AlibabaCloud::Facebody::Model::EnhanceFaceRequest;
EnhanceFaceRequest::EnhanceFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "EnhanceFace")
{
setMethod(HttpRequest::Method::Post);
}
EnhanceFaceRequest::~EnhanceFaceRequest()
{}
std::string EnhanceFaceRequest::getImageURL()const
{
return imageURL_;
}
void EnhanceFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/EnhanceFaceRequest.cc
|
C++
|
apache-2.0
| 1,163
|
/*
* 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/facebody/model/EnhanceFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
EnhanceFaceResult::EnhanceFaceResult() :
ServiceResult()
{}
EnhanceFaceResult::EnhanceFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EnhanceFaceResult::~EnhanceFaceResult()
{}
void EnhanceFaceResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
EnhanceFaceResult::Data EnhanceFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/EnhanceFaceResult.cc
|
C++
|
apache-2.0
| 1,392
|
/*
* 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/facebody/model/ExtractPedestrianFeatureAttrRequest.h>
using AlibabaCloud::Facebody::Model::ExtractPedestrianFeatureAttrRequest;
ExtractPedestrianFeatureAttrRequest::ExtractPedestrianFeatureAttrRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ExtractPedestrianFeatureAttr")
{
setMethod(HttpRequest::Method::Post);
}
ExtractPedestrianFeatureAttrRequest::~ExtractPedestrianFeatureAttrRequest()
{}
std::string ExtractPedestrianFeatureAttrRequest::getMode()const
{
return mode_;
}
void ExtractPedestrianFeatureAttrRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
}
std::string ExtractPedestrianFeatureAttrRequest::getImageURL()const
{
return imageURL_;
}
void ExtractPedestrianFeatureAttrRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ExtractPedestrianFeatureAttrRequest.cc
|
C++
|
apache-2.0
| 1,539
|
/*
* 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/facebody/model/ExtractPedestrianFeatureAttrResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ExtractPedestrianFeatureAttrResult::ExtractPedestrianFeatureAttrResult() :
ServiceResult()
{}
ExtractPedestrianFeatureAttrResult::ExtractPedestrianFeatureAttrResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractPedestrianFeatureAttrResult::~ExtractPedestrianFeatureAttrResult()
{}
void ExtractPedestrianFeatureAttrResult::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["ObjType"].isNull())
data_.objType = dataNode["ObjType"].asString();
if(!dataNode["ObjTypeScore"].isNull())
data_.objTypeScore = std::stof(dataNode["ObjTypeScore"].asString());
if(!dataNode["Feature"].isNull())
data_.feature = dataNode["Feature"].asString();
if(!dataNode["QualityScore"].isNull())
data_.qualityScore = std::stof(dataNode["QualityScore"].asString());
if(!dataNode["UpperColor"].isNull())
data_.upperColor = dataNode["UpperColor"].asString();
if(!dataNode["UpperColorScore"].isNull())
data_.upperColorScore = std::stof(dataNode["UpperColorScore"].asString());
if(!dataNode["UpperType"].isNull())
data_.upperType = dataNode["UpperType"].asString();
if(!dataNode["UpperTypeScore"].isNull())
data_.upperTypeScore = std::stof(dataNode["UpperTypeScore"].asString());
if(!dataNode["LowerColor"].isNull())
data_.lowerColor = dataNode["LowerColor"].asString();
if(!dataNode["LowerColorScore"].isNull())
data_.lowerColorScore = std::stof(dataNode["LowerColorScore"].asString());
if(!dataNode["LowerType"].isNull())
data_.lowerType = dataNode["LowerType"].asString();
if(!dataNode["LowerTypeScore"].isNull())
data_.lowerTypeScore = std::stof(dataNode["LowerTypeScore"].asString());
if(!dataNode["Gender"].isNull())
data_.gender = dataNode["Gender"].asString();
if(!dataNode["GenderScore"].isNull())
data_.genderScore = std::stof(dataNode["GenderScore"].asString());
if(!dataNode["Hair"].isNull())
data_.hair = dataNode["Hair"].asString();
if(!dataNode["HairScore"].isNull())
data_.hairScore = std::stof(dataNode["HairScore"].asString());
if(!dataNode["Age"].isNull())
data_.age = dataNode["Age"].asString();
if(!dataNode["AgeScore"].isNull())
data_.ageScore = std::stof(dataNode["AgeScore"].asString());
}
ExtractPedestrianFeatureAttrResult::Data ExtractPedestrianFeatureAttrResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ExtractPedestrianFeatureAttrResult.cc
|
C++
|
apache-2.0
| 3,250
|
/*
* 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/facebody/model/ExtractPedestrianFeatureAttributeRequest.h>
using AlibabaCloud::Facebody::Model::ExtractPedestrianFeatureAttributeRequest;
ExtractPedestrianFeatureAttributeRequest::ExtractPedestrianFeatureAttributeRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ExtractPedestrianFeatureAttribute")
{
setMethod(HttpRequest::Method::Post);
}
ExtractPedestrianFeatureAttributeRequest::~ExtractPedestrianFeatureAttributeRequest()
{}
std::vector<ExtractPedestrianFeatureAttributeRequest::UrlList> ExtractPedestrianFeatureAttributeRequest::getUrlList()const
{
return urlList_;
}
void ExtractPedestrianFeatureAttributeRequest::setUrlList(const std::vector<UrlList>& urlList)
{
urlList_ = urlList;
for(int dep1 = 0; dep1!= urlList.size(); dep1++) {
auto urlListObj = urlList.at(dep1);
std::string urlListObjStr = "UrlList." + std::to_string(dep1 + 1);
setParameter(urlListObjStr + ".Url", urlListObj.url);
}
}
std::string ExtractPedestrianFeatureAttributeRequest::getMode()const
{
return mode_;
}
void ExtractPedestrianFeatureAttributeRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
}
std::string ExtractPedestrianFeatureAttributeRequest::getImageURL()const
{
return imageURL_;
}
void ExtractPedestrianFeatureAttributeRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ExtractPedestrianFeatureAttributeRequest.cc
|
C++
|
apache-2.0
| 2,093
|
/*
* 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/facebody/model/ExtractPedestrianFeatureAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ExtractPedestrianFeatureAttributeResult::ExtractPedestrianFeatureAttributeResult() :
ServiceResult()
{}
ExtractPedestrianFeatureAttributeResult::ExtractPedestrianFeatureAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractPedestrianFeatureAttributeResult::~ExtractPedestrianFeatureAttributeResult()
{}
void ExtractPedestrianFeatureAttributeResult::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["ObjType"].isNull())
data_.objType = dataNode["ObjType"].asString();
if(!dataNode["ObjTypeScore"].isNull())
data_.objTypeScore = std::stof(dataNode["ObjTypeScore"].asString());
if(!dataNode["Feature"].isNull())
data_.feature = dataNode["Feature"].asString();
if(!dataNode["QualityScore"].isNull())
data_.qualityScore = std::stof(dataNode["QualityScore"].asString());
if(!dataNode["UpperColor"].isNull())
data_.upperColor = dataNode["UpperColor"].asString();
if(!dataNode["UpperColorScore"].isNull())
data_.upperColorScore = std::stof(dataNode["UpperColorScore"].asString());
if(!dataNode["UpperType"].isNull())
data_.upperType = dataNode["UpperType"].asString();
if(!dataNode["UpperTypeScore"].isNull())
data_.upperTypeScore = std::stof(dataNode["UpperTypeScore"].asString());
if(!dataNode["LowerColor"].isNull())
data_.lowerColor = dataNode["LowerColor"].asString();
if(!dataNode["LowerColorScore"].isNull())
data_.lowerColorScore = std::stof(dataNode["LowerColorScore"].asString());
if(!dataNode["LowerType"].isNull())
data_.lowerType = dataNode["LowerType"].asString();
if(!dataNode["LowerTypeScore"].isNull())
data_.lowerTypeScore = std::stof(dataNode["LowerTypeScore"].asString());
if(!dataNode["Gender"].isNull())
data_.gender = dataNode["Gender"].asString();
if(!dataNode["GenderScore"].isNull())
data_.genderScore = std::stof(dataNode["GenderScore"].asString());
if(!dataNode["Hair"].isNull())
data_.hair = dataNode["Hair"].asString();
if(!dataNode["HairScore"].isNull())
data_.hairScore = std::stof(dataNode["HairScore"].asString());
if(!dataNode["Age"].isNull())
data_.age = dataNode["Age"].asString();
if(!dataNode["AgeScore"].isNull())
data_.ageScore = std::stof(dataNode["AgeScore"].asString());
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["ObjType"].isNull())
elementObject.objType = dataNodeElementsElement["ObjType"].asString();
if(!dataNodeElementsElement["ObjTypeScore"].isNull())
elementObject.objTypeScore = std::stof(dataNodeElementsElement["ObjTypeScore"].asString());
if(!dataNodeElementsElement["Feature"].isNull())
elementObject.feature = dataNodeElementsElement["Feature"].asString();
if(!dataNodeElementsElement["QualityScore"].isNull())
elementObject.qualityScore = std::stof(dataNodeElementsElement["QualityScore"].asString());
if(!dataNodeElementsElement["UpperColor"].isNull())
elementObject.upperColor = dataNodeElementsElement["UpperColor"].asString();
if(!dataNodeElementsElement["UpperColorScore"].isNull())
elementObject.upperColorScore = std::stof(dataNodeElementsElement["UpperColorScore"].asString());
if(!dataNodeElementsElement["UpperType"].isNull())
elementObject.upperType = dataNodeElementsElement["UpperType"].asString();
if(!dataNodeElementsElement["UpperTypeScore"].isNull())
elementObject.upperTypeScore = std::stof(dataNodeElementsElement["UpperTypeScore"].asString());
if(!dataNodeElementsElement["LowerColor"].isNull())
elementObject.lowerColor = dataNodeElementsElement["LowerColor"].asString();
if(!dataNodeElementsElement["LowerColorScore"].isNull())
elementObject.lowerColorScore = std::stof(dataNodeElementsElement["LowerColorScore"].asString());
if(!dataNodeElementsElement["LowerType"].isNull())
elementObject.lowerType = dataNodeElementsElement["LowerType"].asString();
if(!dataNodeElementsElement["LowerTypeScore"].isNull())
elementObject.lowerTypeScore = std::stof(dataNodeElementsElement["LowerTypeScore"].asString());
if(!dataNodeElementsElement["Gender"].isNull())
elementObject.gender = dataNodeElementsElement["Gender"].asString();
if(!dataNodeElementsElement["GenderScore"].isNull())
elementObject.genderScore = std::stof(dataNodeElementsElement["GenderScore"].asString());
if(!dataNodeElementsElement["Hair"].isNull())
elementObject.hair = dataNodeElementsElement["Hair"].asString();
if(!dataNodeElementsElement["HairScore"].isNull())
elementObject.hairScore = std::stof(dataNodeElementsElement["HairScore"].asString());
if(!dataNodeElementsElement["Age"].isNull())
elementObject.age = dataNodeElementsElement["Age"].asString();
if(!dataNodeElementsElement["AgeScore"].isNull())
elementObject.ageScore = std::stof(dataNodeElementsElement["AgeScore"].asString());
data_.elements.push_back(elementObject);
}
}
ExtractPedestrianFeatureAttributeResult::Data ExtractPedestrianFeatureAttributeResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ExtractPedestrianFeatureAttributeResult.cc
|
C++
|
apache-2.0
| 5,987
|
/*
* 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/facebody/model/FaceBeautyRequest.h>
using AlibabaCloud::Facebody::Model::FaceBeautyRequest;
FaceBeautyRequest::FaceBeautyRequest() :
RpcServiceRequest("facebody", "2019-12-30", "FaceBeauty")
{
setMethod(HttpRequest::Method::Post);
}
FaceBeautyRequest::~FaceBeautyRequest()
{}
float FaceBeautyRequest::getSharp()const
{
return sharp_;
}
void FaceBeautyRequest::setSharp(float sharp)
{
sharp_ = sharp;
setBodyParameter("Sharp", std::to_string(sharp));
}
float FaceBeautyRequest::getWhite()const
{
return white_;
}
void FaceBeautyRequest::setWhite(float white)
{
white_ = white;
setBodyParameter("White", std::to_string(white));
}
std::string FaceBeautyRequest::getImageURL()const
{
return imageURL_;
}
void FaceBeautyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
float FaceBeautyRequest::getSmooth()const
{
return smooth_;
}
void FaceBeautyRequest::setSmooth(float smooth)
{
smooth_ = smooth;
setBodyParameter("Smooth", std::to_string(smooth));
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceBeautyRequest.cc
|
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.
*/
#include <alibabacloud/facebody/model/FaceBeautyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
FaceBeautyResult::FaceBeautyResult() :
ServiceResult()
{}
FaceBeautyResult::FaceBeautyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FaceBeautyResult::~FaceBeautyResult()
{}
void FaceBeautyResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
FaceBeautyResult::Data FaceBeautyResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceBeautyResult.cc
|
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.
*/
#include <alibabacloud/facebody/model/FaceFilterRequest.h>
using AlibabaCloud::Facebody::Model::FaceFilterRequest;
FaceFilterRequest::FaceFilterRequest() :
RpcServiceRequest("facebody", "2019-12-30", "FaceFilter")
{
setMethod(HttpRequest::Method::Post);
}
FaceFilterRequest::~FaceFilterRequest()
{}
float FaceFilterRequest::getStrength()const
{
return strength_;
}
void FaceFilterRequest::setStrength(float strength)
{
strength_ = strength;
setBodyParameter("Strength", std::to_string(strength));
}
std::string FaceFilterRequest::getResourceType()const
{
return resourceType_;
}
void FaceFilterRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setBodyParameter("ResourceType", resourceType);
}
std::string FaceFilterRequest::getImageURL()const
{
return imageURL_;
}
void FaceFilterRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceFilterRequest.cc
|
C++
|
apache-2.0
| 1,621
|
/*
* 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/facebody/model/FaceFilterResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
FaceFilterResult::FaceFilterResult() :
ServiceResult()
{}
FaceFilterResult::FaceFilterResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FaceFilterResult::~FaceFilterResult()
{}
void FaceFilterResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
FaceFilterResult::Data FaceFilterResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceFilterResult.cc
|
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.
*/
#include <alibabacloud/facebody/model/FaceMakeupRequest.h>
using AlibabaCloud::Facebody::Model::FaceMakeupRequest;
FaceMakeupRequest::FaceMakeupRequest() :
RpcServiceRequest("facebody", "2019-12-30", "FaceMakeup")
{
setMethod(HttpRequest::Method::Post);
}
FaceMakeupRequest::~FaceMakeupRequest()
{}
float FaceMakeupRequest::getStrength()const
{
return strength_;
}
void FaceMakeupRequest::setStrength(float strength)
{
strength_ = strength;
setBodyParameter("Strength", std::to_string(strength));
}
std::string FaceMakeupRequest::getMakeupType()const
{
return makeupType_;
}
void FaceMakeupRequest::setMakeupType(const std::string& makeupType)
{
makeupType_ = makeupType;
setBodyParameter("MakeupType", makeupType);
}
std::string FaceMakeupRequest::getResourceType()const
{
return resourceType_;
}
void FaceMakeupRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setBodyParameter("ResourceType", resourceType);
}
std::string FaceMakeupRequest::getImageURL()const
{
return imageURL_;
}
void FaceMakeupRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceMakeupRequest.cc
|
C++
|
apache-2.0
| 1,856
|
/*
* 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/facebody/model/FaceMakeupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
FaceMakeupResult::FaceMakeupResult() :
ServiceResult()
{}
FaceMakeupResult::FaceMakeupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FaceMakeupResult::~FaceMakeupResult()
{}
void FaceMakeupResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
FaceMakeupResult::Data FaceMakeupResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceMakeupResult.cc
|
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.
*/
#include <alibabacloud/facebody/model/FaceTidyupRequest.h>
using AlibabaCloud::Facebody::Model::FaceTidyupRequest;
FaceTidyupRequest::FaceTidyupRequest() :
RpcServiceRequest("facebody", "2019-12-30", "FaceTidyup")
{
setMethod(HttpRequest::Method::Post);
}
FaceTidyupRequest::~FaceTidyupRequest()
{}
int FaceTidyupRequest::getShapeType()const
{
return shapeType_;
}
void FaceTidyupRequest::setShapeType(int shapeType)
{
shapeType_ = shapeType;
setBodyParameter("ShapeType", std::to_string(shapeType));
}
float FaceTidyupRequest::getStrength()const
{
return strength_;
}
void FaceTidyupRequest::setStrength(float strength)
{
strength_ = strength;
setBodyParameter("Strength", std::to_string(strength));
}
std::string FaceTidyupRequest::getImageURL()const
{
return imageURL_;
}
void FaceTidyupRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceTidyupRequest.cc
|
C++
|
apache-2.0
| 1,590
|
/*
* 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/facebody/model/FaceTidyupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
FaceTidyupResult::FaceTidyupResult() :
ServiceResult()
{}
FaceTidyupResult::FaceTidyupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FaceTidyupResult::~FaceTidyupResult()
{}
void FaceTidyupResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
FaceTidyupResult::Data FaceTidyupResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/FaceTidyupResult.cc
|
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.
*/
#include <alibabacloud/facebody/model/GenerateHumanAnimeStyleRequest.h>
using AlibabaCloud::Facebody::Model::GenerateHumanAnimeStyleRequest;
GenerateHumanAnimeStyleRequest::GenerateHumanAnimeStyleRequest() :
RpcServiceRequest("facebody", "2019-12-30", "GenerateHumanAnimeStyle")
{
setMethod(HttpRequest::Method::Post);
}
GenerateHumanAnimeStyleRequest::~GenerateHumanAnimeStyleRequest()
{}
std::string GenerateHumanAnimeStyleRequest::getAlgoType()const
{
return algoType_;
}
void GenerateHumanAnimeStyleRequest::setAlgoType(const std::string& algoType)
{
algoType_ = algoType;
setParameter("AlgoType", algoType);
}
std::string GenerateHumanAnimeStyleRequest::getImageURL()const
{
return imageURL_;
}
void GenerateHumanAnimeStyleRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/GenerateHumanAnimeStyleRequest.cc
|
C++
|
apache-2.0
| 1,508
|
/*
* 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/facebody/model/GenerateHumanAnimeStyleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
GenerateHumanAnimeStyleResult::GenerateHumanAnimeStyleResult() :
ServiceResult()
{}
GenerateHumanAnimeStyleResult::GenerateHumanAnimeStyleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenerateHumanAnimeStyleResult::~GenerateHumanAnimeStyleResult()
{}
void GenerateHumanAnimeStyleResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
GenerateHumanAnimeStyleResult::Data GenerateHumanAnimeStyleResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/GenerateHumanAnimeStyleResult.cc
|
C++
|
apache-2.0
| 1,512
|
/*
* 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/facebody/model/GetFaceEntityRequest.h>
using AlibabaCloud::Facebody::Model::GetFaceEntityRequest;
GetFaceEntityRequest::GetFaceEntityRequest() :
RpcServiceRequest("facebody", "2019-12-30", "GetFaceEntity")
{
setMethod(HttpRequest::Method::Post);
}
GetFaceEntityRequest::~GetFaceEntityRequest()
{}
std::string GetFaceEntityRequest::getEntityId()const
{
return entityId_;
}
void GetFaceEntityRequest::setEntityId(const std::string& entityId)
{
entityId_ = entityId;
setBodyParameter("EntityId", entityId);
}
std::string GetFaceEntityRequest::getDbName()const
{
return dbName_;
}
void GetFaceEntityRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/GetFaceEntityRequest.cc
|
C++
|
apache-2.0
| 1,390
|
/*
* 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/facebody/model/GetFaceEntityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
GetFaceEntityResult::GetFaceEntityResult() :
ServiceResult()
{}
GetFaceEntityResult::GetFaceEntityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetFaceEntityResult::~GetFaceEntityResult()
{}
void GetFaceEntityResult::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["DbName"].isNull())
data_.dbName = dataNode["DbName"].asString();
if(!dataNode["EntityId"].isNull())
data_.entityId = dataNode["EntityId"].asString();
if(!dataNode["Labels"].isNull())
data_.labels = dataNode["Labels"].asString();
auto allFacesNode = dataNode["Faces"]["Face"];
for (auto dataNodeFacesFace : allFacesNode)
{
Data::Face faceObject;
if(!dataNodeFacesFace["FaceId"].isNull())
faceObject.faceId = dataNodeFacesFace["FaceId"].asString();
data_.faces.push_back(faceObject);
}
}
GetFaceEntityResult::Data GetFaceEntityResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/GetFaceEntityResult.cc
|
C++
|
apache-2.0
| 1,844
|
/*
* 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/facebody/model/HandPostureRequest.h>
using AlibabaCloud::Facebody::Model::HandPostureRequest;
HandPostureRequest::HandPostureRequest() :
RpcServiceRequest("facebody", "2019-12-30", "HandPosture")
{
setMethod(HttpRequest::Method::Post);
}
HandPostureRequest::~HandPostureRequest()
{}
std::string HandPostureRequest::getImageURL()const
{
return imageURL_;
}
void HandPostureRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/HandPostureRequest.cc
|
C++
|
apache-2.0
| 1,163
|
/*
* 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/facebody/model/HandPostureResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
HandPostureResult::HandPostureResult() :
ServiceResult()
{}
HandPostureResult::HandPostureResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HandPostureResult::~HandPostureResult()
{}
void HandPostureResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allOutputsNode = dataNode["Outputs"]["Output"];
for (auto dataNodeOutputsOutput : allOutputsNode)
{
Data::Output outputObject;
if(!dataNodeOutputsOutput["HandCount"].isNull())
outputObject.handCount = std::stoi(dataNodeOutputsOutput["HandCount"].asString());
auto allResultsNode = dataNodeOutputsOutput["Results"]["Result"];
for (auto dataNodeOutputsOutputResultsResult : allResultsNode)
{
Data::Output::Result resultsObject;
auto boxNode = value["Box"];
if(!boxNode["Confident"].isNull())
resultsObject.box.confident = std::stof(boxNode["Confident"].asString());
auto allPositionsNode = boxNode["Positions"]["Position"];
for (auto boxNodePositionsPosition : allPositionsNode)
{
Data::Output::Result::Box::Position positionObject;
auto allPoints = value["Points"]["Point"];
for (auto value : allPoints)
positionObject.points.push_back(value.asString());
resultsObject.box.positions.push_back(positionObject);
}
auto handsNode = value["Hands"];
if(!handsNode["Confident"].isNull())
resultsObject.hands.confident = std::stof(handsNode["Confident"].asString());
auto allKeyPointsNode = handsNode["KeyPoints"]["KeyPoint"];
for (auto handsNodeKeyPointsKeyPoint : allKeyPointsNode)
{
Data::Output::Result::Hands::KeyPoint keyPointObject;
if(!handsNodeKeyPointsKeyPoint["Label"].isNull())
keyPointObject.label = handsNodeKeyPointsKeyPoint["Label"].asString();
auto allPositions1Node = handsNodeKeyPointsKeyPoint["Positions"]["Position"];
for (auto handsNodeKeyPointsKeyPointPositionsPosition : allPositions1Node)
{
Data::Output::Result::Hands::KeyPoint::Position2 positions1Object;
auto allPoints3 = value["Points"]["Point"];
for (auto value : allPoints3)
positions1Object.points3.push_back(value.asString());
keyPointObject.positions1.push_back(positions1Object);
}
resultsObject.hands.keyPoints.push_back(keyPointObject);
}
outputObject.results.push_back(resultsObject);
}
data_.outputs.push_back(outputObject);
}
auto metaObjectNode = dataNode["MetaObject"];
if(!metaObjectNode["Height"].isNull())
data_.metaObject.height = std::stoi(metaObjectNode["Height"].asString());
if(!metaObjectNode["Width"].isNull())
data_.metaObject.width = std::stoi(metaObjectNode["Width"].asString());
}
HandPostureResult::Data HandPostureResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/HandPostureResult.cc
|
C++
|
apache-2.0
| 3,645
|
/*
* 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/facebody/model/ListFaceDbsRequest.h>
using AlibabaCloud::Facebody::Model::ListFaceDbsRequest;
ListFaceDbsRequest::ListFaceDbsRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ListFaceDbs")
{
setMethod(HttpRequest::Method::Post);
}
ListFaceDbsRequest::~ListFaceDbsRequest()
{}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ListFaceDbsRequest.cc
|
C++
|
apache-2.0
| 942
|
/*
* 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/facebody/model/ListFaceDbsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ListFaceDbsResult::ListFaceDbsResult() :
ServiceResult()
{}
ListFaceDbsResult::ListFaceDbsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListFaceDbsResult::~ListFaceDbsResult()
{}
void ListFaceDbsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allDbListNode = dataNode["DbList"]["DbListItem"];
for (auto dataNodeDbListDbListItem : allDbListNode)
{
Data::DbListItem dbListItemObject;
if(!dataNodeDbListDbListItem["Name"].isNull())
dbListItemObject.name = dataNodeDbListDbListItem["Name"].asString();
data_.dbList.push_back(dbListItemObject);
}
}
ListFaceDbsResult::Data ListFaceDbsResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ListFaceDbsResult.cc
|
C++
|
apache-2.0
| 1,621
|
/*
* 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/facebody/model/ListFaceEntitiesRequest.h>
using AlibabaCloud::Facebody::Model::ListFaceEntitiesRequest;
ListFaceEntitiesRequest::ListFaceEntitiesRequest() :
RpcServiceRequest("facebody", "2019-12-30", "ListFaceEntities")
{
setMethod(HttpRequest::Method::Post);
}
ListFaceEntitiesRequest::~ListFaceEntitiesRequest()
{}
std::string ListFaceEntitiesRequest::getEntityIdPrefix()const
{
return entityIdPrefix_;
}
void ListFaceEntitiesRequest::setEntityIdPrefix(const std::string& entityIdPrefix)
{
entityIdPrefix_ = entityIdPrefix;
setBodyParameter("EntityIdPrefix", entityIdPrefix);
}
int ListFaceEntitiesRequest::getLimit()const
{
return limit_;
}
void ListFaceEntitiesRequest::setLimit(int limit)
{
limit_ = limit;
setBodyParameter("Limit", std::to_string(limit));
}
std::string ListFaceEntitiesRequest::getOrder()const
{
return order_;
}
void ListFaceEntitiesRequest::setOrder(const std::string& order)
{
order_ = order;
setBodyParameter("Order", order);
}
int ListFaceEntitiesRequest::getOffset()const
{
return offset_;
}
void ListFaceEntitiesRequest::setOffset(int offset)
{
offset_ = offset;
setBodyParameter("Offset", std::to_string(offset));
}
std::string ListFaceEntitiesRequest::getToken()const
{
return token_;
}
void ListFaceEntitiesRequest::setToken(const std::string& token)
{
token_ = token;
setBodyParameter("Token", token);
}
std::string ListFaceEntitiesRequest::getLabels()const
{
return labels_;
}
void ListFaceEntitiesRequest::setLabels(const std::string& labels)
{
labels_ = labels;
setBodyParameter("Labels", labels);
}
std::string ListFaceEntitiesRequest::getDbName()const
{
return dbName_;
}
void ListFaceEntitiesRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ListFaceEntitiesRequest.cc
|
C++
|
apache-2.0
| 2,508
|
/*
* 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/facebody/model/ListFaceEntitiesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
ListFaceEntitiesResult::ListFaceEntitiesResult() :
ServiceResult()
{}
ListFaceEntitiesResult::ListFaceEntitiesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListFaceEntitiesResult::~ListFaceEntitiesResult()
{}
void ListFaceEntitiesResult::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["Token"].isNull())
data_.token = dataNode["Token"].asString();
if(!dataNode["TotalCount"].isNull())
data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
auto allEntitiesNode = dataNode["Entities"]["Entity"];
for (auto dataNodeEntitiesEntity : allEntitiesNode)
{
Data::Entity entityObject;
if(!dataNodeEntitiesEntity["DbName"].isNull())
entityObject.dbName = dataNodeEntitiesEntity["DbName"].asString();
if(!dataNodeEntitiesEntity["EntityId"].isNull())
entityObject.entityId = dataNodeEntitiesEntity["EntityId"].asString();
if(!dataNodeEntitiesEntity["FaceCount"].isNull())
entityObject.faceCount = std::stoi(dataNodeEntitiesEntity["FaceCount"].asString());
if(!dataNodeEntitiesEntity["Labels"].isNull())
entityObject.labels = dataNodeEntitiesEntity["Labels"].asString();
if(!dataNodeEntitiesEntity["CreatedAt"].isNull())
entityObject.createdAt = std::stol(dataNodeEntitiesEntity["CreatedAt"].asString());
if(!dataNodeEntitiesEntity["UpdatedAt"].isNull())
entityObject.updatedAt = std::stol(dataNodeEntitiesEntity["UpdatedAt"].asString());
data_.entities.push_back(entityObject);
}
}
ListFaceEntitiesResult::Data ListFaceEntitiesResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/ListFaceEntitiesResult.cc
|
C++
|
apache-2.0
| 2,504
|
/*
* 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/facebody/model/PedestrianDetectAttributeRequest.h>
using AlibabaCloud::Facebody::Model::PedestrianDetectAttributeRequest;
PedestrianDetectAttributeRequest::PedestrianDetectAttributeRequest() :
RpcServiceRequest("facebody", "2019-12-30", "PedestrianDetectAttribute")
{
setMethod(HttpRequest::Method::Post);
}
PedestrianDetectAttributeRequest::~PedestrianDetectAttributeRequest()
{}
std::string PedestrianDetectAttributeRequest::getImageURL()const
{
return imageURL_;
}
void PedestrianDetectAttributeRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/PedestrianDetectAttributeRequest.cc
|
C++
|
apache-2.0
| 1,289
|
/*
* 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/facebody/model/PedestrianDetectAttributeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
PedestrianDetectAttributeResult::PedestrianDetectAttributeResult() :
ServiceResult()
{}
PedestrianDetectAttributeResult::PedestrianDetectAttributeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PedestrianDetectAttributeResult::~PedestrianDetectAttributeResult()
{}
void PedestrianDetectAttributeResult::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["PersonNumber"].isNull())
data_.personNumber = std::stoi(dataNode["PersonNumber"].asString());
auto allAttributesNode = dataNode["Attributes"]["AttributesItem"];
for (auto dataNodeAttributesAttributesItem : allAttributesNode)
{
Data::AttributesItem attributesItemObject;
auto ageNode = value["Age"];
if(!ageNode["Name"].isNull())
attributesItemObject.age.name = ageNode["Name"].asString();
if(!ageNode["Score"].isNull())
attributesItemObject.age.score = std::stof(ageNode["Score"].asString());
auto backpackNode = value["Backpack"];
if(!backpackNode["Name"].isNull())
attributesItemObject.backpack.name = backpackNode["Name"].asString();
if(!backpackNode["Score"].isNull())
attributesItemObject.backpack.score = std::stof(backpackNode["Score"].asString());
auto genderNode = value["Gender"];
if(!genderNode["Name"].isNull())
attributesItemObject.gender.name = genderNode["Name"].asString();
if(!genderNode["Score"].isNull())
attributesItemObject.gender.score = std::stof(genderNode["Score"].asString());
auto glassesNode = value["Glasses"];
if(!glassesNode["Name"].isNull())
attributesItemObject.glasses.name = glassesNode["Name"].asString();
if(!glassesNode["Score"].isNull())
attributesItemObject.glasses.score = std::stof(glassesNode["Score"].asString());
auto handbagNode = value["Handbag"];
if(!handbagNode["Name"].isNull())
attributesItemObject.handbag.name = handbagNode["Name"].asString();
if(!handbagNode["Score"].isNull())
attributesItemObject.handbag.score = std::stof(handbagNode["Score"].asString());
auto hatNode = value["Hat"];
if(!hatNode["Name"].isNull())
attributesItemObject.hat.name = hatNode["Name"].asString();
if(!hatNode["Score"].isNull())
attributesItemObject.hat.score = std::stof(hatNode["Score"].asString());
auto lowerColorNode = value["LowerColor"];
if(!lowerColorNode["Name"].isNull())
attributesItemObject.lowerColor.name = lowerColorNode["Name"].asString();
if(!lowerColorNode["Score"].isNull())
attributesItemObject.lowerColor.score = std::stof(lowerColorNode["Score"].asString());
auto lowerWearNode = value["LowerWear"];
if(!lowerWearNode["Name"].isNull())
attributesItemObject.lowerWear.name = lowerWearNode["Name"].asString();
if(!lowerWearNode["Score"].isNull())
attributesItemObject.lowerWear.score = std::stof(lowerWearNode["Score"].asString());
auto orientNode = value["Orient"];
if(!orientNode["Name"].isNull())
attributesItemObject.orient.name = orientNode["Name"].asString();
if(!orientNode["Score"].isNull())
attributesItemObject.orient.score = std::stof(orientNode["Score"].asString());
auto shoulderBagNode = value["ShoulderBag"];
if(!shoulderBagNode["Name"].isNull())
attributesItemObject.shoulderBag.name = shoulderBagNode["Name"].asString();
if(!shoulderBagNode["Score"].isNull())
attributesItemObject.shoulderBag.score = std::stof(shoulderBagNode["Score"].asString());
auto upperColorNode = value["UpperColor"];
if(!upperColorNode["Name"].isNull())
attributesItemObject.upperColor.name = upperColorNode["Name"].asString();
if(!upperColorNode["Score"].isNull())
attributesItemObject.upperColor.score = std::stof(upperColorNode["Score"].asString());
auto upperWearNode = value["UpperWear"];
if(!upperWearNode["Name"].isNull())
attributesItemObject.upperWear.name = upperWearNode["Name"].asString();
if(!upperWearNode["Score"].isNull())
attributesItemObject.upperWear.score = std::stof(upperWearNode["Score"].asString());
data_.attributes.push_back(attributesItemObject);
}
auto allBoxesNode = dataNode["Boxes"]["BoxesItem"];
for (auto dataNodeBoxesBoxesItem : allBoxesNode)
{
Data::BoxesItem boxesItemObject;
if(!dataNodeBoxesBoxesItem["Score"].isNull())
boxesItemObject.score = std::stof(dataNodeBoxesBoxesItem["Score"].asString());
if(!dataNodeBoxesBoxesItem["TopLeftX"].isNull())
boxesItemObject.topLeftX = std::stof(dataNodeBoxesBoxesItem["TopLeftX"].asString());
if(!dataNodeBoxesBoxesItem["TopLeftY"].isNull())
boxesItemObject.topLeftY = std::stof(dataNodeBoxesBoxesItem["TopLeftY"].asString());
if(!dataNodeBoxesBoxesItem["BottomRightX"].isNull())
boxesItemObject.bottomRightX = std::stof(dataNodeBoxesBoxesItem["BottomRightX"].asString());
if(!dataNodeBoxesBoxesItem["BottomRightY"].isNull())
boxesItemObject.bottomRightY = std::stof(dataNodeBoxesBoxesItem["BottomRightY"].asString());
data_.boxes.push_back(boxesItemObject);
}
}
PedestrianDetectAttributeResult::Data PedestrianDetectAttributeResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/PedestrianDetectAttributeResult.cc
|
C++
|
apache-2.0
| 5,931
|
/*
* 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/facebody/model/RecognizeActionRequest.h>
using AlibabaCloud::Facebody::Model::RecognizeActionRequest;
RecognizeActionRequest::RecognizeActionRequest() :
RpcServiceRequest("facebody", "2019-12-30", "RecognizeAction")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeActionRequest::~RecognizeActionRequest()
{}
std::vector<RecognizeActionRequest::URLList> RecognizeActionRequest::getURLList()const
{
return uRLList_;
}
void RecognizeActionRequest::setURLList(const std::vector<URLList>& uRLList)
{
uRLList_ = uRLList;
for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
auto uRLListObj = uRLList.at(dep1);
std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
}
}
int RecognizeActionRequest::getType()const
{
return type_;
}
void RecognizeActionRequest::setType(int type)
{
type_ = type;
setBodyParameter("Type", std::to_string(type));
}
std::string RecognizeActionRequest::getVideoUrl()const
{
return videoUrl_;
}
void RecognizeActionRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeActionRequest.cc
|
C++
|
apache-2.0
| 1,834
|
/*
* 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/facebody/model/RecognizeActionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
RecognizeActionResult::RecognizeActionResult() :
ServiceResult()
{}
RecognizeActionResult::RecognizeActionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeActionResult::~RecognizeActionResult()
{}
void RecognizeActionResult::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["Timestamp"].isNull())
elementObject.timestamp = std::stoi(dataNodeElementsElement["Timestamp"].asString());
auto allBoxesNode = dataNodeElementsElement["Boxes"]["BoxesItem"];
for (auto dataNodeElementsElementBoxesBoxesItem : allBoxesNode)
{
Data::Element::BoxesItem boxesObject;
auto allBox = value["Box"]["Box"];
for (auto value : allBox)
boxesObject.box.push_back(value.asString());
elementObject.boxes.push_back(boxesObject);
}
auto allScores = value["Scores"]["Score"];
for (auto value : allScores)
elementObject.scores.push_back(value.asString());
auto allLabels = value["Labels"]["Label"];
for (auto value : allLabels)
elementObject.labels.push_back(value.asString());
data_.elements.push_back(elementObject);
}
}
RecognizeActionResult::Data RecognizeActionResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeActionResult.cc
|
C++
|
apache-2.0
| 2,282
|
/*
* 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/facebody/model/RecognizeExpressionRequest.h>
using AlibabaCloud::Facebody::Model::RecognizeExpressionRequest;
RecognizeExpressionRequest::RecognizeExpressionRequest() :
RpcServiceRequest("facebody", "2019-12-30", "RecognizeExpression")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeExpressionRequest::~RecognizeExpressionRequest()
{}
std::string RecognizeExpressionRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeExpressionRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeExpressionRequest.cc
|
C++
|
apache-2.0
| 1,235
|
/*
* 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/facebody/model/RecognizeExpressionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
RecognizeExpressionResult::RecognizeExpressionResult() :
ServiceResult()
{}
RecognizeExpressionResult::RecognizeExpressionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeExpressionResult::~RecognizeExpressionResult()
{}
void RecognizeExpressionResult::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"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Expression"].isNull())
elementObject.expression = dataNodeElementsElement["Expression"].asString();
if(!dataNodeElementsElement["FaceProbability"].isNull())
elementObject.faceProbability = std::stof(dataNodeElementsElement["FaceProbability"].asString());
auto faceRectangleNode = value["FaceRectangle"];
if(!faceRectangleNode["Height"].isNull())
elementObject.faceRectangle.height = std::stoi(faceRectangleNode["Height"].asString());
if(!faceRectangleNode["Left"].isNull())
elementObject.faceRectangle.left = std::stoi(faceRectangleNode["Left"].asString());
if(!faceRectangleNode["Top"].isNull())
elementObject.faceRectangle.top = std::stoi(faceRectangleNode["Top"].asString());
if(!faceRectangleNode["Width"].isNull())
elementObject.faceRectangle.width = std::stoi(faceRectangleNode["Width"].asString());
data_.elements.push_back(elementObject);
}
}
RecognizeExpressionResult::Data RecognizeExpressionResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeExpressionResult.cc
|
C++
|
apache-2.0
| 2,431
|
/*
* 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/facebody/model/RecognizeFaceRequest.h>
using AlibabaCloud::Facebody::Model::RecognizeFaceRequest;
RecognizeFaceRequest::RecognizeFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "RecognizeFace")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeFaceRequest::~RecognizeFaceRequest()
{}
int RecognizeFaceRequest::getImageType()const
{
return imageType_;
}
void RecognizeFaceRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
std::string RecognizeFaceRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeFaceRequest.cc
|
C++
|
apache-2.0
| 1,407
|
/*
* 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/facebody/model/RecognizeFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
RecognizeFaceResult::RecognizeFaceResult() :
ServiceResult()
{}
RecognizeFaceResult::RecognizeFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeFaceResult::~RecognizeFaceResult()
{}
void RecognizeFaceResult::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["LandmarkCount"].isNull())
data_.landmarkCount = std::stoi(dataNode["LandmarkCount"].asString());
if(!dataNode["DenseFeatureLength"].isNull())
data_.denseFeatureLength = std::stoi(dataNode["DenseFeatureLength"].asString());
if(!dataNode["FaceCount"].isNull())
data_.faceCount = std::stoi(dataNode["FaceCount"].asString());
auto qualitiesNode = dataNode["Qualities"];
auto allNoiseList = qualitiesNode["NoiseList"]["Noise"];
for (auto value : allNoiseList)
data_.qualities.noiseList.push_back(value.asString());
auto allScoreList = qualitiesNode["ScoreList"]["Score"];
for (auto value : allScoreList)
data_.qualities.scoreList.push_back(value.asString());
auto allBlurList = qualitiesNode["BlurList"]["Blur"];
for (auto value : allBlurList)
data_.qualities.blurList.push_back(value.asString());
auto allMaskList = qualitiesNode["MaskList"]["Mask"];
for (auto value : allMaskList)
data_.qualities.maskList.push_back(value.asString());
auto allGlassList = qualitiesNode["GlassList"]["Glass"];
for (auto value : allGlassList)
data_.qualities.glassList.push_back(value.asString());
auto allFnfList = qualitiesNode["FnfList"]["Fnf"];
for (auto value : allFnfList)
data_.qualities.fnfList.push_back(value.asString());
auto allPoseList1 = qualitiesNode["PoseList"]["Pose"];
for (auto value : allPoseList1)
data_.qualities.poseList1.push_back(value.asString());
auto allIlluList = qualitiesNode["IlluList"]["Illu"];
for (auto value : allIlluList)
data_.qualities.illuList.push_back(value.asString());
auto allDenseFeatures = dataNode["DenseFeatures"]["DenseFeature"];
for (auto value : allDenseFeatures)
data_.denseFeatures.push_back(value.asString());
auto allFaceProbabilityList = dataNode["FaceProbabilityList"]["FaceProbability"];
for (auto value : allFaceProbabilityList)
data_.faceProbabilityList.push_back(value.asString());
auto allHatList = dataNode["HatList"]["Hat"];
for (auto value : allHatList)
data_.hatList.push_back(value.asString());
auto allAgeList = dataNode["AgeList"]["Age"];
for (auto value : allAgeList)
data_.ageList.push_back(value.asString());
auto allBeuatyList = dataNode["BeuatyList"]["Beauty"];
for (auto value : allBeuatyList)
data_.beuatyList.push_back(value.asString());
auto allFaceRectangles = dataNode["FaceRectangles"]["FaceRectangle"];
for (auto value : allFaceRectangles)
data_.faceRectangles.push_back(value.asString());
auto allGlasses = dataNode["Glasses"]["Glass"];
for (auto value : allGlasses)
data_.glasses.push_back(value.asString());
auto allLandmarks = dataNode["Landmarks"]["Landmark"];
for (auto value : allLandmarks)
data_.landmarks.push_back(value.asString());
auto allExpressions = dataNode["Expressions"]["Expression"];
for (auto value : allExpressions)
data_.expressions.push_back(value.asString());
auto allPoseList = dataNode["PoseList"]["Pose"];
for (auto value : allPoseList)
data_.poseList.push_back(value.asString());
auto allGenderList = dataNode["GenderList"]["Gender"];
for (auto value : allGenderList)
data_.genderList.push_back(value.asString());
auto allPupils = dataNode["Pupils"]["Pupil"];
for (auto value : allPupils)
data_.pupils.push_back(value.asString());
}
RecognizeFaceResult::Data RecognizeFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizeFaceResult.cc
|
C++
|
apache-2.0
| 4,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.
*/
#include <alibabacloud/facebody/model/RecognizePublicFaceRequest.h>
using AlibabaCloud::Facebody::Model::RecognizePublicFaceRequest;
RecognizePublicFaceRequest::RecognizePublicFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "RecognizePublicFace")
{
setMethod(HttpRequest::Method::Post);
}
RecognizePublicFaceRequest::~RecognizePublicFaceRequest()
{}
std::vector<RecognizePublicFaceRequest::Task> RecognizePublicFaceRequest::getTask()const
{
return task_;
}
void RecognizePublicFaceRequest::setTask(const std::vector<Task>& task)
{
task_ = task;
for(int dep1 = 0; dep1!= task.size(); dep1++) {
auto taskObj = task.at(dep1);
std::string taskObjStr = "Task." + std::to_string(dep1 + 1);
setParameter(taskObjStr + ".ImageURL", taskObj.imageURL);
}
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizePublicFaceRequest.cc
|
C++
|
apache-2.0
| 1,420
|
/*
* 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/facebody/model/RecognizePublicFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
RecognizePublicFaceResult::RecognizePublicFaceResult() :
ServiceResult()
{}
RecognizePublicFaceResult::RecognizePublicFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizePublicFaceResult::~RecognizePublicFaceResult()
{}
void RecognizePublicFaceResult::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["TaskId"].isNull())
elementObject.taskId = dataNodeElementsElement["TaskId"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
auto allResultsNode = dataNodeElementsElement["Results"]["Result"];
for (auto dataNodeElementsElementResultsResult : allResultsNode)
{
Data::Element::Result resultsObject;
if(!dataNodeElementsElementResultsResult["Label"].isNull())
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
auto allSubResultsNode = dataNodeElementsElementResultsResult["SubResults"]["SubResult"];
for (auto dataNodeElementsElementResultsResultSubResultsSubResult : allSubResultsNode)
{
Data::Element::Result::SubResult subResultsObject;
if(!dataNodeElementsElementResultsResultSubResultsSubResult["H"].isNull())
subResultsObject.h = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["H"].asString());
if(!dataNodeElementsElementResultsResultSubResultsSubResult["W"].isNull())
subResultsObject.w = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["W"].asString());
if(!dataNodeElementsElementResultsResultSubResultsSubResult["X"].isNull())
subResultsObject.x = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["X"].asString());
if(!dataNodeElementsElementResultsResultSubResultsSubResult["Y"].isNull())
subResultsObject.y = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["Y"].asString());
auto allFacesNode = dataNodeElementsElementResultsResultSubResultsSubResult["Faces"]["Face"];
for (auto dataNodeElementsElementResultsResultSubResultsSubResultFacesFace : allFacesNode)
{
Data::Element::Result::SubResult::Face facesObject;
if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Id"].isNull())
facesObject.id = dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Id"].asString();
if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Name"].isNull())
facesObject.name = dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Name"].asString();
if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].isNull())
facesObject.rate = std::stof(dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].asString());
subResultsObject.faces.push_back(facesObject);
}
resultsObject.subResults.push_back(subResultsObject);
}
elementObject.results.push_back(resultsObject);
}
data_.elements.push_back(elementObject);
}
}
RecognizePublicFaceResult::Data RecognizePublicFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/RecognizePublicFaceResult.cc
|
C++
|
apache-2.0
| 4,512
|
/*
* 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/facebody/model/SearchFaceRequest.h>
using AlibabaCloud::Facebody::Model::SearchFaceRequest;
SearchFaceRequest::SearchFaceRequest() :
RpcServiceRequest("facebody", "2019-12-30", "SearchFace")
{
setMethod(HttpRequest::Method::Post);
}
SearchFaceRequest::~SearchFaceRequest()
{}
std::string SearchFaceRequest::getDbNames()const
{
return dbNames_;
}
void SearchFaceRequest::setDbNames(const std::string& dbNames)
{
dbNames_ = dbNames;
setParameter("DbNames", dbNames);
}
std::string SearchFaceRequest::getDbName()const
{
return dbName_;
}
void SearchFaceRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
std::string SearchFaceRequest::getImageUrl()const
{
return imageUrl_;
}
void SearchFaceRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
int SearchFaceRequest::getLimit()const
{
return limit_;
}
void SearchFaceRequest::setLimit(int limit)
{
limit_ = limit;
setBodyParameter("Limit", std::to_string(limit));
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/SearchFaceRequest.cc
|
C++
|
apache-2.0
| 1,752
|
/*
* 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/facebody/model/SearchFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
SearchFaceResult::SearchFaceResult() :
ServiceResult()
{}
SearchFaceResult::SearchFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SearchFaceResult::~SearchFaceResult()
{}
void SearchFaceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allMatchListNode = dataNode["MatchList"]["MatchListItem"];
for (auto dataNodeMatchListMatchListItem : allMatchListNode)
{
Data::MatchListItem matchListItemObject;
auto allFaceItemsNode = dataNodeMatchListMatchListItem["FaceItems"]["FaceItemsItem"];
for (auto dataNodeMatchListMatchListItemFaceItemsFaceItemsItem : allFaceItemsNode)
{
Data::MatchListItem::FaceItemsItem faceItemsObject;
if(!dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["FaceId"].isNull())
faceItemsObject.faceId = dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["FaceId"].asString();
if(!dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["EntityId"].isNull())
faceItemsObject.entityId = dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["EntityId"].asString();
if(!dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["Score"].isNull())
faceItemsObject.score = std::stof(dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["Score"].asString());
if(!dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["DbName"].isNull())
faceItemsObject.dbName = dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["DbName"].asString();
if(!dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["ExtraData"].isNull())
faceItemsObject.extraData = dataNodeMatchListMatchListItemFaceItemsFaceItemsItem["ExtraData"].asString();
matchListItemObject.faceItems.push_back(faceItemsObject);
}
auto locationNode = value["Location"];
if(!locationNode["X"].isNull())
matchListItemObject.location.x = std::stoi(locationNode["X"].asString());
if(!locationNode["Y"].isNull())
matchListItemObject.location.y = std::stoi(locationNode["Y"].asString());
if(!locationNode["Height"].isNull())
matchListItemObject.location.height = std::stoi(locationNode["Height"].asString());
if(!locationNode["Width"].isNull())
matchListItemObject.location.width = std::stoi(locationNode["Width"].asString());
data_.matchList.push_back(matchListItemObject);
}
}
SearchFaceResult::Data SearchFaceResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/SearchFaceResult.cc
|
C++
|
apache-2.0
| 3,272
|
/*
* 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/facebody/model/SwapFacialFeaturesRequest.h>
using AlibabaCloud::Facebody::Model::SwapFacialFeaturesRequest;
SwapFacialFeaturesRequest::SwapFacialFeaturesRequest() :
RpcServiceRequest("facebody", "2019-12-30", "SwapFacialFeatures")
{
setMethod(HttpRequest::Method::Post);
}
SwapFacialFeaturesRequest::~SwapFacialFeaturesRequest()
{}
std::string SwapFacialFeaturesRequest::getTargetImageURL()const
{
return targetImageURL_;
}
void SwapFacialFeaturesRequest::setTargetImageURL(const std::string& targetImageURL)
{
targetImageURL_ = targetImageURL;
setBodyParameter("TargetImageURL", targetImageURL);
}
std::string SwapFacialFeaturesRequest::getSourceImageURL()const
{
return sourceImageURL_;
}
void SwapFacialFeaturesRequest::setSourceImageURL(const std::string& sourceImageURL)
{
sourceImageURL_ = sourceImageURL;
setBodyParameter("SourceImageURL", sourceImageURL);
}
std::string SwapFacialFeaturesRequest::getEditPart()const
{
return editPart_;
}
void SwapFacialFeaturesRequest::setEditPart(const std::string& editPart)
{
editPart_ = editPart;
setBodyParameter("EditPart", editPart);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/SwapFacialFeaturesRequest.cc
|
C++
|
apache-2.0
| 1,792
|
/*
* 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/facebody/model/SwapFacialFeaturesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
SwapFacialFeaturesResult::SwapFacialFeaturesResult() :
ServiceResult()
{}
SwapFacialFeaturesResult::SwapFacialFeaturesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SwapFacialFeaturesResult::~SwapFacialFeaturesResult()
{}
void SwapFacialFeaturesResult::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["ImageURL"].isNull())
data_.imageURL = dataNode["ImageURL"].asString();
}
SwapFacialFeaturesResult::Data SwapFacialFeaturesResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/SwapFacialFeaturesResult.cc
|
C++
|
apache-2.0
| 1,462
|
/*
* 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/facebody/model/UpdateFaceEntityRequest.h>
using AlibabaCloud::Facebody::Model::UpdateFaceEntityRequest;
UpdateFaceEntityRequest::UpdateFaceEntityRequest() :
RpcServiceRequest("facebody", "2019-12-30", "UpdateFaceEntity")
{
setMethod(HttpRequest::Method::Post);
}
UpdateFaceEntityRequest::~UpdateFaceEntityRequest()
{}
std::string UpdateFaceEntityRequest::getEntityId()const
{
return entityId_;
}
void UpdateFaceEntityRequest::setEntityId(const std::string& entityId)
{
entityId_ = entityId;
setBodyParameter("EntityId", entityId);
}
std::string UpdateFaceEntityRequest::getLabels()const
{
return labels_;
}
void UpdateFaceEntityRequest::setLabels(const std::string& labels)
{
labels_ = labels;
setBodyParameter("Labels", labels);
}
std::string UpdateFaceEntityRequest::getDbName()const
{
return dbName_;
}
void UpdateFaceEntityRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/UpdateFaceEntityRequest.cc
|
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.
*/
#include <alibabacloud/facebody/model/UpdateFaceEntityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
UpdateFaceEntityResult::UpdateFaceEntityResult() :
ServiceResult()
{}
UpdateFaceEntityResult::UpdateFaceEntityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateFaceEntityResult::~UpdateFaceEntityResult()
{}
void UpdateFaceEntityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/UpdateFaceEntityResult.cc
|
C++
|
apache-2.0
| 1,234
|
/*
* 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/facebody/model/VerifyFaceMaskRequest.h>
using AlibabaCloud::Facebody::Model::VerifyFaceMaskRequest;
VerifyFaceMaskRequest::VerifyFaceMaskRequest() :
RpcServiceRequest("facebody", "2019-12-30", "VerifyFaceMask")
{
setMethod(HttpRequest::Method::Post);
}
VerifyFaceMaskRequest::~VerifyFaceMaskRequest()
{}
std::string VerifyFaceMaskRequest::getImageURL()const
{
return imageURL_;
}
void VerifyFaceMaskRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
std::string VerifyFaceMaskRequest::getRefUrl()const
{
return refUrl_;
}
void VerifyFaceMaskRequest::setRefUrl(const std::string& refUrl)
{
refUrl_ = refUrl;
setBodyParameter("RefUrl", refUrl);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/VerifyFaceMaskRequest.cc
|
C++
|
apache-2.0
| 1,401
|
/*
* 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/facebody/model/VerifyFaceMaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
VerifyFaceMaskResult::VerifyFaceMaskResult() :
ServiceResult()
{}
VerifyFaceMaskResult::VerifyFaceMaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
VerifyFaceMaskResult::~VerifyFaceMaskResult()
{}
void VerifyFaceMaskResult::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["Confidence"].isNull())
data_.confidence = std::stof(dataNode["Confidence"].asString());
if(!dataNode["Mask"].isNull())
data_.mask = std::stoi(dataNode["Mask"].asString());
if(!dataNode["MaskRef"].isNull())
data_.maskRef = std::stoi(dataNode["MaskRef"].asString());
auto allRectangle = dataNode["Rectangle"]["Rectangle"];
for (auto value : allRectangle)
data_.rectangle.push_back(value.asString());
auto allRectangleRef = dataNode["RectangleRef"]["RectangleRef"];
for (auto value : allRectangleRef)
data_.rectangleRef.push_back(value.asString());
auto allThresholds = dataNode["Thresholds"]["Thresholds"];
for (auto value : allThresholds)
data_.thresholds.push_back(value.asString());
}
VerifyFaceMaskResult::Data VerifyFaceMaskResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/VerifyFaceMaskResult.cc
|
C++
|
apache-2.0
| 2,062
|
#!/bin/bash
cd `dirname $0`
echo '-------build function test----------'
MAKE=make
if command -v python > /dev/null ; then
MAKE="make -j $(python -c 'import multiprocessing as mp; print(int(mp.cpu_count()))')"
fi
echo $MAKE
FT_BUILD_DIR=ft_build
rm -rf $FT_BUILD_DIR
mkdir $FT_BUILD_DIR
cd $FT_BUILD_DIR
cmake -DBUILD_FUNCTION_TESTS=ON -DBUILD_UNIT_TESTS=OFF ..
$MAKE cdn core cs ecs rds slb vpc cdn_ft core_ft cs_ft ecs_ft nlp_ft rds_ft slb_ft vpc_ft
echo '------- run function test -----------'
ctest --verbose
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/function_test.sh
|
Shell
|
apache-2.0
| 520
|
#!/bin/bash
cd `dirname $0`
UT_BUILD_DIR=ut_build
echo '--------- generate initial info ---------------- '
lcov -d $UT_BUILD_DIR -z
lcov -d $UT_BUILD_DIR -b . --no-external --initial -c -o initCoverage.info
echo '--------- run test ---------------- '
cd $UT_BUILD_DIR
ctest --verbose
cd ..
echo '--------- generate post info ---------------- '
lcov -d $UT_BUILD_DIR -b . --no-external -c -o testCoverage.info
echo '--------- generate html report ---------------- '
genhtml -o coverageReport --prefix=`pwd` initCoverage.info testCoverage.info
echo 'check report: ' `pwd`/coverageReport/index.html
echo ' ------remove tmp file ------'
rm initCoverage.info
rm testCoverage.info
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/generate_code_cov.sh
|
Shell
|
apache-2.0
| 685
|
#
# 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(imageenhan_public_header
include/alibabacloud/imageenhan/ImageenhanClient.h
include/alibabacloud/imageenhan/ImageenhanExport.h )
set(imageenhan_public_header_model
include/alibabacloud/imageenhan/model/AssessCompositionRequest.h
include/alibabacloud/imageenhan/model/AssessCompositionResult.h
include/alibabacloud/imageenhan/model/AssessExposureRequest.h
include/alibabacloud/imageenhan/model/AssessExposureResult.h
include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h
include/alibabacloud/imageenhan/model/AssessSharpnessResult.h
include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h
include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h
include/alibabacloud/imageenhan/model/ColorizeImageRequest.h
include/alibabacloud/imageenhan/model/ColorizeImageResult.h
include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h
include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h
include/alibabacloud/imageenhan/model/ErasePersonRequest.h
include/alibabacloud/imageenhan/model/ErasePersonResult.h
include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h
include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h
include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h
include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h
include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h
include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h
include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h
include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h
include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h
include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h
include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h
include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h
include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h
include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h
include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h
include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h
include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h
include/alibabacloud/imageenhan/model/RecolorHDImageResult.h
include/alibabacloud/imageenhan/model/RecolorImageRequest.h
include/alibabacloud/imageenhan/model/RecolorImageResult.h
include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h
include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h
include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h
include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h )
set(imageenhan_src
src/ImageenhanClient.cc
src/model/AssessCompositionRequest.cc
src/model/AssessCompositionResult.cc
src/model/AssessExposureRequest.cc
src/model/AssessExposureResult.cc
src/model/AssessSharpnessRequest.cc
src/model/AssessSharpnessResult.cc
src/model/ChangeImageSizeRequest.cc
src/model/ChangeImageSizeResult.cc
src/model/ColorizeImageRequest.cc
src/model/ColorizeImageResult.cc
src/model/EnhanceImageColorRequest.cc
src/model/EnhanceImageColorResult.cc
src/model/ErasePersonRequest.cc
src/model/ErasePersonResult.cc
src/model/ExtendImageStyleRequest.cc
src/model/ExtendImageStyleResult.cc
src/model/GenerateDynamicImageRequest.cc
src/model/GenerateDynamicImageResult.cc
src/model/GetAsyncJobResultRequest.cc
src/model/GetAsyncJobResultResult.cc
src/model/ImageBlindCharacterWatermarkRequest.cc
src/model/ImageBlindCharacterWatermarkResult.cc
src/model/ImageBlindPicWatermarkRequest.cc
src/model/ImageBlindPicWatermarkResult.cc
src/model/ImitatePhotoStyleRequest.cc
src/model/ImitatePhotoStyleResult.cc
src/model/IntelligentCompositionRequest.cc
src/model/IntelligentCompositionResult.cc
src/model/MakeSuperResolutionImageRequest.cc
src/model/MakeSuperResolutionImageResult.cc
src/model/RecolorHDImageRequest.cc
src/model/RecolorHDImageResult.cc
src/model/RecolorImageRequest.cc
src/model/RecolorImageResult.cc
src/model/RemoveImageSubtitlesRequest.cc
src/model/RemoveImageSubtitlesResult.cc
src/model/RemoveImageWatermarkRequest.cc
src/model/RemoveImageWatermarkResult.cc )
add_library(imageenhan ${LIB_TYPE}
${imageenhan_public_header}
${imageenhan_public_header_model}
${imageenhan_src})
set_target_properties(imageenhan
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}imageenhan
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(imageenhan
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_IMAGEENHAN_LIBRARY)
endif()
target_include_directories(imageenhan
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(imageenhan
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(imageenhan
jsoncpp)
target_include_directories(imageenhan
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(imageenhan
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(imageenhan
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(imageenhan
PRIVATE /usr/include/jsoncpp)
target_link_libraries(imageenhan
jsoncpp)
endif()
install(FILES ${imageenhan_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan)
install(FILES ${imageenhan_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan/model)
install(TARGETS imageenhan
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/imageenhan/CMakeLists.txt
|
CMake
|
apache-2.0
| 6,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_IMAGEENHAN_IMAGEENHANCLIENT_H_
#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ImageenhanExport.h"
#include "model/AssessCompositionRequest.h"
#include "model/AssessCompositionResult.h"
#include "model/AssessExposureRequest.h"
#include "model/AssessExposureResult.h"
#include "model/AssessSharpnessRequest.h"
#include "model/AssessSharpnessResult.h"
#include "model/ChangeImageSizeRequest.h"
#include "model/ChangeImageSizeResult.h"
#include "model/ColorizeImageRequest.h"
#include "model/ColorizeImageResult.h"
#include "model/EnhanceImageColorRequest.h"
#include "model/EnhanceImageColorResult.h"
#include "model/ErasePersonRequest.h"
#include "model/ErasePersonResult.h"
#include "model/ExtendImageStyleRequest.h"
#include "model/ExtendImageStyleResult.h"
#include "model/GenerateDynamicImageRequest.h"
#include "model/GenerateDynamicImageResult.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/ImageBlindCharacterWatermarkRequest.h"
#include "model/ImageBlindCharacterWatermarkResult.h"
#include "model/ImageBlindPicWatermarkRequest.h"
#include "model/ImageBlindPicWatermarkResult.h"
#include "model/ImitatePhotoStyleRequest.h"
#include "model/ImitatePhotoStyleResult.h"
#include "model/IntelligentCompositionRequest.h"
#include "model/IntelligentCompositionResult.h"
#include "model/MakeSuperResolutionImageRequest.h"
#include "model/MakeSuperResolutionImageResult.h"
#include "model/RecolorHDImageRequest.h"
#include "model/RecolorHDImageResult.h"
#include "model/RecolorImageRequest.h"
#include "model/RecolorImageResult.h"
#include "model/RemoveImageSubtitlesRequest.h"
#include "model/RemoveImageSubtitlesResult.h"
#include "model/RemoveImageWatermarkRequest.h"
#include "model/RemoveImageWatermarkResult.h"
namespace AlibabaCloud
{
namespace Imageenhan
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageenhanClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AssessCompositionResult> AssessCompositionOutcome;
typedef std::future<AssessCompositionOutcome> AssessCompositionOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessCompositionRequest&, const AssessCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessCompositionAsyncHandler;
typedef Outcome<Error, Model::AssessExposureResult> AssessExposureOutcome;
typedef std::future<AssessExposureOutcome> AssessExposureOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessExposureRequest&, const AssessExposureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessExposureAsyncHandler;
typedef Outcome<Error, Model::AssessSharpnessResult> AssessSharpnessOutcome;
typedef std::future<AssessSharpnessOutcome> AssessSharpnessOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessSharpnessRequest&, const AssessSharpnessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessSharpnessAsyncHandler;
typedef Outcome<Error, Model::ChangeImageSizeResult> ChangeImageSizeOutcome;
typedef std::future<ChangeImageSizeOutcome> ChangeImageSizeOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ChangeImageSizeRequest&, const ChangeImageSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeImageSizeAsyncHandler;
typedef Outcome<Error, Model::ColorizeImageResult> ColorizeImageOutcome;
typedef std::future<ColorizeImageOutcome> ColorizeImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ColorizeImageRequest&, const ColorizeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ColorizeImageAsyncHandler;
typedef Outcome<Error, Model::EnhanceImageColorResult> EnhanceImageColorOutcome;
typedef std::future<EnhanceImageColorOutcome> EnhanceImageColorOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::EnhanceImageColorRequest&, const EnhanceImageColorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceImageColorAsyncHandler;
typedef Outcome<Error, Model::ErasePersonResult> ErasePersonOutcome;
typedef std::future<ErasePersonOutcome> ErasePersonOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ErasePersonRequest&, const ErasePersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ErasePersonAsyncHandler;
typedef Outcome<Error, Model::ExtendImageStyleResult> ExtendImageStyleOutcome;
typedef std::future<ExtendImageStyleOutcome> ExtendImageStyleOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ExtendImageStyleRequest&, const ExtendImageStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtendImageStyleAsyncHandler;
typedef Outcome<Error, Model::GenerateDynamicImageResult> GenerateDynamicImageOutcome;
typedef std::future<GenerateDynamicImageOutcome> GenerateDynamicImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::GenerateDynamicImageRequest&, const GenerateDynamicImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDynamicImageAsyncHandler;
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::ImageBlindCharacterWatermarkResult> ImageBlindCharacterWatermarkOutcome;
typedef std::future<ImageBlindCharacterWatermarkOutcome> ImageBlindCharacterWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindCharacterWatermarkRequest&, const ImageBlindCharacterWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindCharacterWatermarkAsyncHandler;
typedef Outcome<Error, Model::ImageBlindPicWatermarkResult> ImageBlindPicWatermarkOutcome;
typedef std::future<ImageBlindPicWatermarkOutcome> ImageBlindPicWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindPicWatermarkRequest&, const ImageBlindPicWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindPicWatermarkAsyncHandler;
typedef Outcome<Error, Model::ImitatePhotoStyleResult> ImitatePhotoStyleOutcome;
typedef std::future<ImitatePhotoStyleOutcome> ImitatePhotoStyleOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImitatePhotoStyleRequest&, const ImitatePhotoStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImitatePhotoStyleAsyncHandler;
typedef Outcome<Error, Model::IntelligentCompositionResult> IntelligentCompositionOutcome;
typedef std::future<IntelligentCompositionOutcome> IntelligentCompositionOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::IntelligentCompositionRequest&, const IntelligentCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IntelligentCompositionAsyncHandler;
typedef Outcome<Error, Model::MakeSuperResolutionImageResult> MakeSuperResolutionImageOutcome;
typedef std::future<MakeSuperResolutionImageOutcome> MakeSuperResolutionImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::MakeSuperResolutionImageRequest&, const MakeSuperResolutionImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MakeSuperResolutionImageAsyncHandler;
typedef Outcome<Error, Model::RecolorHDImageResult> RecolorHDImageOutcome;
typedef std::future<RecolorHDImageOutcome> RecolorHDImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RecolorHDImageRequest&, const RecolorHDImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorHDImageAsyncHandler;
typedef Outcome<Error, Model::RecolorImageResult> RecolorImageOutcome;
typedef std::future<RecolorImageOutcome> RecolorImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RecolorImageRequest&, const RecolorImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorImageAsyncHandler;
typedef Outcome<Error, Model::RemoveImageSubtitlesResult> RemoveImageSubtitlesOutcome;
typedef std::future<RemoveImageSubtitlesOutcome> RemoveImageSubtitlesOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageSubtitlesRequest&, const RemoveImageSubtitlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageSubtitlesAsyncHandler;
typedef Outcome<Error, Model::RemoveImageWatermarkResult> RemoveImageWatermarkOutcome;
typedef std::future<RemoveImageWatermarkOutcome> RemoveImageWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageWatermarkRequest&, const RemoveImageWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageWatermarkAsyncHandler;
ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration);
ImageenhanClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ImageenhanClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ImageenhanClient();
AssessCompositionOutcome assessComposition(const Model::AssessCompositionRequest &request)const;
void assessCompositionAsync(const Model::AssessCompositionRequest& request, const AssessCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessCompositionOutcomeCallable assessCompositionCallable(const Model::AssessCompositionRequest& request) const;
AssessExposureOutcome assessExposure(const Model::AssessExposureRequest &request)const;
void assessExposureAsync(const Model::AssessExposureRequest& request, const AssessExposureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessExposureOutcomeCallable assessExposureCallable(const Model::AssessExposureRequest& request) const;
AssessSharpnessOutcome assessSharpness(const Model::AssessSharpnessRequest &request)const;
void assessSharpnessAsync(const Model::AssessSharpnessRequest& request, const AssessSharpnessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessSharpnessOutcomeCallable assessSharpnessCallable(const Model::AssessSharpnessRequest& request) const;
ChangeImageSizeOutcome changeImageSize(const Model::ChangeImageSizeRequest &request)const;
void changeImageSizeAsync(const Model::ChangeImageSizeRequest& request, const ChangeImageSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeImageSizeOutcomeCallable changeImageSizeCallable(const Model::ChangeImageSizeRequest& request) const;
ColorizeImageOutcome colorizeImage(const Model::ColorizeImageRequest &request)const;
void colorizeImageAsync(const Model::ColorizeImageRequest& request, const ColorizeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ColorizeImageOutcomeCallable colorizeImageCallable(const Model::ColorizeImageRequest& request) const;
EnhanceImageColorOutcome enhanceImageColor(const Model::EnhanceImageColorRequest &request)const;
void enhanceImageColorAsync(const Model::EnhanceImageColorRequest& request, const EnhanceImageColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnhanceImageColorOutcomeCallable enhanceImageColorCallable(const Model::EnhanceImageColorRequest& request) const;
ErasePersonOutcome erasePerson(const Model::ErasePersonRequest &request)const;
void erasePersonAsync(const Model::ErasePersonRequest& request, const ErasePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ErasePersonOutcomeCallable erasePersonCallable(const Model::ErasePersonRequest& request) const;
ExtendImageStyleOutcome extendImageStyle(const Model::ExtendImageStyleRequest &request)const;
void extendImageStyleAsync(const Model::ExtendImageStyleRequest& request, const ExtendImageStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtendImageStyleOutcomeCallable extendImageStyleCallable(const Model::ExtendImageStyleRequest& request) const;
GenerateDynamicImageOutcome generateDynamicImage(const Model::GenerateDynamicImageRequest &request)const;
void generateDynamicImageAsync(const Model::GenerateDynamicImageRequest& request, const GenerateDynamicImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateDynamicImageOutcomeCallable generateDynamicImageCallable(const Model::GenerateDynamicImageRequest& 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;
ImageBlindCharacterWatermarkOutcome imageBlindCharacterWatermark(const Model::ImageBlindCharacterWatermarkRequest &request)const;
void imageBlindCharacterWatermarkAsync(const Model::ImageBlindCharacterWatermarkRequest& request, const ImageBlindCharacterWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageBlindCharacterWatermarkOutcomeCallable imageBlindCharacterWatermarkCallable(const Model::ImageBlindCharacterWatermarkRequest& request) const;
ImageBlindPicWatermarkOutcome imageBlindPicWatermark(const Model::ImageBlindPicWatermarkRequest &request)const;
void imageBlindPicWatermarkAsync(const Model::ImageBlindPicWatermarkRequest& request, const ImageBlindPicWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageBlindPicWatermarkOutcomeCallable imageBlindPicWatermarkCallable(const Model::ImageBlindPicWatermarkRequest& request) const;
ImitatePhotoStyleOutcome imitatePhotoStyle(const Model::ImitatePhotoStyleRequest &request)const;
void imitatePhotoStyleAsync(const Model::ImitatePhotoStyleRequest& request, const ImitatePhotoStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImitatePhotoStyleOutcomeCallable imitatePhotoStyleCallable(const Model::ImitatePhotoStyleRequest& request) const;
IntelligentCompositionOutcome intelligentComposition(const Model::IntelligentCompositionRequest &request)const;
void intelligentCompositionAsync(const Model::IntelligentCompositionRequest& request, const IntelligentCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
IntelligentCompositionOutcomeCallable intelligentCompositionCallable(const Model::IntelligentCompositionRequest& request) const;
MakeSuperResolutionImageOutcome makeSuperResolutionImage(const Model::MakeSuperResolutionImageRequest &request)const;
void makeSuperResolutionImageAsync(const Model::MakeSuperResolutionImageRequest& request, const MakeSuperResolutionImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MakeSuperResolutionImageOutcomeCallable makeSuperResolutionImageCallable(const Model::MakeSuperResolutionImageRequest& request) const;
RecolorHDImageOutcome recolorHDImage(const Model::RecolorHDImageRequest &request)const;
void recolorHDImageAsync(const Model::RecolorHDImageRequest& request, const RecolorHDImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecolorHDImageOutcomeCallable recolorHDImageCallable(const Model::RecolorHDImageRequest& request) const;
RecolorImageOutcome recolorImage(const Model::RecolorImageRequest &request)const;
void recolorImageAsync(const Model::RecolorImageRequest& request, const RecolorImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecolorImageOutcomeCallable recolorImageCallable(const Model::RecolorImageRequest& request) const;
RemoveImageSubtitlesOutcome removeImageSubtitles(const Model::RemoveImageSubtitlesRequest &request)const;
void removeImageSubtitlesAsync(const Model::RemoveImageSubtitlesRequest& request, const RemoveImageSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveImageSubtitlesOutcomeCallable removeImageSubtitlesCallable(const Model::RemoveImageSubtitlesRequest& request) const;
RemoveImageWatermarkOutcome removeImageWatermark(const Model::RemoveImageWatermarkRequest &request)const;
void removeImageWatermarkAsync(const Model::RemoveImageWatermarkRequest& request, const RemoveImageWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveImageWatermarkOutcomeCallable removeImageWatermarkCallable(const Model::RemoveImageWatermarkRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h
|
C++
|
apache-2.0
| 18,602
|
/*
* 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_IMAGEENHAN_IMAGEENHANEXPORT_H_
#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_IMAGEENHAN_LIBRARY)
# define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_IMAGEENHAN_EXPORT
#endif
#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h
|
C
|
apache-2.0
| 1,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.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionRequest : public RpcServiceRequest
{
public:
AssessCompositionRequest();
~AssessCompositionRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h
|
C++
|
apache-2.0
| 1,371
|
/*
* 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_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionResult : public ServiceResult
{
public:
struct Data
{
float score;
};
AssessCompositionResult();
explicit AssessCompositionResult(const std::string &payload);
~AssessCompositionResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h
|
C++
|
apache-2.0
| 1,462
|
/*
* 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_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureRequest : public RpcServiceRequest
{
public:
AssessExposureRequest();
~AssessExposureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h
|
C++
|
apache-2.0
| 1,353
|
/*
* 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_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureResult : public ServiceResult
{
public:
struct Data
{
float exposure;
};
AssessExposureResult();
explicit AssessExposureResult(const std::string &payload);
~AssessExposureResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h
|
C++
|
apache-2.0
| 1,444
|
/*
* 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_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessRequest : public RpcServiceRequest
{
public:
AssessSharpnessRequest();
~AssessSharpnessRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h
|
C++
|
apache-2.0
| 1,359
|
/*
* 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_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessResult : public ServiceResult
{
public:
struct Data
{
float sharpness;
};
AssessSharpnessResult();
explicit AssessSharpnessResult(const std::string &payload);
~AssessSharpnessResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h
|
C++
|
apache-2.0
| 1,452
|
/*
* 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_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeRequest : public RpcServiceRequest
{
public:
ChangeImageSizeRequest();
~ChangeImageSizeRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
int getWidth()const;
void setWidth(int width);
int getHeight()const;
void setHeight(int height);
private:
std::string url_;
int width_;
int height_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h
|
C++
|
apache-2.0
| 1,491
|
/*
* 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_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeResult : public ServiceResult
{
public:
struct Data
{
struct RetainLocation
{
int x;
int y;
int height;
int width;
};
RetainLocation retainLocation;
std::string url;
};
ChangeImageSizeResult();
explicit ChangeImageSizeResult(const std::string &payload);
~ChangeImageSizeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h
|
C++
|
apache-2.0
| 1,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.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ColorizeImageRequest : public RpcServiceRequest
{
public:
ColorizeImageRequest();
~ColorizeImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ColorizeImageRequest.h
|
C++
|
apache-2.0
| 1,347
|
/*
* 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_IMAGEENHAN_MODEL_COLORIZEIMAGERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ColorizeImageResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
ColorizeImageResult();
explicit ColorizeImageResult(const std::string &payload);
~ColorizeImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ColorizeImageResult.h
|
C++
|
apache-2.0
| 1,443
|
/*
* 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_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorRequest : public RpcServiceRequest
{
public:
EnhanceImageColorRequest();
~EnhanceImageColorRequest();
std::string getMode()const;
void setMode(const std::string& mode);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
private:
std::string mode_;
std::string imageURL_;
std::string outputFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h
|
C++
|
apache-2.0
| 1,605
|
/*
* 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_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
EnhanceImageColorResult();
explicit EnhanceImageColorResult(const std::string &payload);
~EnhanceImageColorResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h
|
C++
|
apache-2.0
| 1,471
|
/*
* 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_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ErasePersonRequest : public RpcServiceRequest
{
public:
ErasePersonRequest();
~ErasePersonRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
std::string getUserMask()const;
void setUserMask(const std::string& userMask);
private:
std::string imageURL_;
std::string userMask_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ErasePersonRequest.h
|
C++
|
apache-2.0
| 1,452
|
/*
* 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_IMAGEENHAN_MODEL_ERASEPERSONRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ErasePersonResult : public ServiceResult
{
public:
struct Data
{
std::string imageUrl;
};
ErasePersonResult();
explicit ErasePersonResult(const std::string &payload);
~ErasePersonResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ErasePersonResult.h
|
C++
|
apache-2.0
| 1,429
|
/*
* 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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleRequest : public RpcServiceRequest
{
public:
ExtendImageStyleRequest();
~ExtendImageStyleRequest();
std::string getMajorUrl()const;
void setMajorUrl(const std::string& majorUrl);
std::string getStyleUrl()const;
void setStyleUrl(const std::string& styleUrl);
private:
std::string majorUrl_;
std::string styleUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h
|
C++
|
apache-2.0
| 1,482
|
/*
* 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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleResult : public ServiceResult
{
public:
struct Data
{
std::string url;
std::string majorUrl;
};
ExtendImageStyleResult();
explicit ExtendImageStyleResult(const std::string &payload);
~ExtendImageStyleResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h
|
C++
|
apache-2.0
| 1,486
|
/*
* 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_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageRequest : public RpcServiceRequest
{
public:
GenerateDynamicImageRequest();
~GenerateDynamicImageRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getOperation()const;
void setOperation(const std::string& operation);
private:
std::string url_;
std::string operation_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h
|
C++
|
apache-2.0
| 1,490
|