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

Publish Swift.

Browse Source
This commit is contained in:
sdk-team
2022-11-16 08:22:51 +00:00
parent 5d3f641eab
commit bc9938b104
10 changed files with 24 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1338
1.36.1339

4
facebody/CMakeLists.txt
View File

@@ -83,8 +83,6 @@ set(facebody_public_header_model
include/alibabacloud/facebody/model/ExtractFingerPrintResult.h
include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h
include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h
include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h
include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h
include/alibabacloud/facebody/model/FaceBeautyRequest.h
include/alibabacloud/facebody/model/FaceBeautyResult.h
include/alibabacloud/facebody/model/FaceFilterRequest.h
@@ -214,8 +212,6 @@ set(facebody_src
src/model/ExtractFingerPrintResult.cc
src/model/ExtractPedestrianFeatureAttrRequest.cc
src/model/ExtractPedestrianFeatureAttrResult.cc
src/model/ExtractPedestrianFeatureAttributeRequest.cc
src/model/ExtractPedestrianFeatureAttributeResult.cc
src/model/FaceBeautyRequest.cc
src/model/FaceBeautyResult.cc
src/model/FaceFilterRequest.cc

8
facebody/include/alibabacloud/facebody/FacebodyClient.h
View File

@@ -84,8 +84,6 @@
#include "model/ExtractFingerPrintResult.h"
#include "model/ExtractPedestrianFeatureAttrRequest.h"
#include "model/ExtractPedestrianFeatureAttrResult.h"
#include "model/ExtractPedestrianFeatureAttributeRequest.h"
#include "model/ExtractPedestrianFeatureAttributeResult.h"
#include "model/FaceBeautyRequest.h"
#include "model/FaceBeautyResult.h"
#include "model/FaceFilterRequest.h"
@@ -252,9 +250,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ExtractPedestrianFeatureAttrResult> ExtractPedestrianFeatureAttrOutcome;
typedef std::future<ExtractPedestrianFeatureAttrOutcome> ExtractPedestrianFeatureAttrOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttrRequest&, const ExtractPedestrianFeatureAttrOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttrAsyncHandler;
typedef Outcome<Error, Model::ExtractPedestrianFeatureAttributeResult> ExtractPedestrianFeatureAttributeOutcome;
typedef std::future<ExtractPedestrianFeatureAttributeOutcome> ExtractPedestrianFeatureAttributeOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttributeRequest&, const ExtractPedestrianFeatureAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttributeAsyncHandler;
typedef Outcome<Error, Model::FaceBeautyResult> FaceBeautyOutcome;
typedef std::future<FaceBeautyOutcome> FaceBeautyOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::FaceBeautyRequest&, const FaceBeautyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceBeautyAsyncHandler;
@@ -449,9 +444,6 @@ namespace AlibabaCloud
ExtractPedestrianFeatureAttrOutcome extractPedestrianFeatureAttr(const Model::ExtractPedestrianFeatureAttrRequest &request)const;
void extractPedestrianFeatureAttrAsync(const Model::ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractPedestrianFeatureAttrOutcomeCallable extractPedestrianFeatureAttrCallable(const Model::ExtractPedestrianFeatureAttrRequest& request) const;
ExtractPedestrianFeatureAttributeOutcome extractPedestrianFeatureAttribute(const Model::ExtractPedestrianFeatureAttributeRequest &request)const;
void extractPedestrianFeatureAttributeAsync(const Model::ExtractPedestrianFeatureAttributeRequest& request, const ExtractPedestrianFeatureAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractPedestrianFeatureAttributeOutcomeCallable extractPedestrianFeatureAttributeCallable(const Model::ExtractPedestrianFeatureAttributeRequest& request) const;
FaceBeautyOutcome faceBeauty(const Model::FaceBeautyRequest &request)const;
void faceBeautyAsync(const Model::FaceBeautyRequest& request, const FaceBeautyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FaceBeautyOutcomeCallable faceBeautyCallable(const Model::FaceBeautyRequest& request) const;

10
facebody/include/alibabacloud/facebody/model/DetectLivingFaceResult.h
View File

@@ -38,19 +38,29 @@ namespace AlibabaCloud
{
struct Result
{
struct Rect
{
long left;
long top;
long height;
long width;
};
struct Frame
{
float rate;
std::string url;
};
std::string messageTips;
std::vector<Result::Frame> frames;
std::string suggestion;
Rect rect;
float rate;
std::string label;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
long faceNumber;
};
std::vector<Element> elements;
};

60
facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h
View File

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

94
facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h
View File

@@ -1,94 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttributeResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
std::string hair;
float upperTypeScore;
std::string upperType;
float qualityScore;
std::string lowerColor;
std::string gender;
std::string feature;
float upperColorScore;
float lowerColorScore;
float genderScore;
std::string objType;
float lowerTypeScore;
float hairScore;
std::string upperColor;
float ageScore;
std::string lowerType;
float objTypeScore;
std::string age;
};
std::string hair;
float upperTypeScore;
std::string upperType;
float qualityScore;
std::string lowerColor;
std::string gender;
std::vector<Element> elements;
std::string feature;
float upperColorScore;
float lowerColorScore;
float genderScore;
std::string objType;
float lowerTypeScore;
float hairScore;
std::string upperColor;
float ageScore;
std::string lowerType;
float objTypeScore;
std::string age;
};
ExtractPedestrianFeatureAttributeResult();
explicit ExtractPedestrianFeatureAttributeResult(const std::string &payload);
~ExtractPedestrianFeatureAttributeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_

36
facebody/src/FacebodyClient.cc
View File

@@ -1167,42 +1167,6 @@ FacebodyClient::ExtractPedestrianFeatureAttrOutcomeCallable FacebodyClient::extr
return task->get_future();
}
FacebodyClient::ExtractPedestrianFeatureAttributeOutcome FacebodyClient::extractPedestrianFeatureAttribute(const ExtractPedestrianFeatureAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ExtractPedestrianFeatureAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ExtractPedestrianFeatureAttributeOutcome(ExtractPedestrianFeatureAttributeResult(outcome.result()));
else
return ExtractPedestrianFeatureAttributeOutcome(outcome.error());
}
void FacebodyClient::extractPedestrianFeatureAttributeAsync(const ExtractPedestrianFeatureAttributeRequest& request, const ExtractPedestrianFeatureAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, extractPedestrianFeatureAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ExtractPedestrianFeatureAttributeOutcomeCallable FacebodyClient::extractPedestrianFeatureAttributeCallable(const ExtractPedestrianFeatureAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ExtractPedestrianFeatureAttributeOutcome()>>(
[this, request]()
{
return this->extractPedestrianFeatureAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::FaceBeautyOutcome FacebodyClient::faceBeauty(const FaceBeautyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

13
facebody/src/model/DetectLivingFaceResult.cc
View File

@@ -48,6 +48,8 @@ void DetectLivingFaceResult::parse(const std::string &payload)
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["TaskId"].isNull())
elementObject.taskId = dataNodeElementsElement["TaskId"].asString();
if(!dataNodeElementsElement["FaceNumber"].isNull())
elementObject.faceNumber = std::stol(dataNodeElementsElement["FaceNumber"].asString());
auto allResultsNode = dataNodeElementsElement["Results"]["Result"];
for (auto dataNodeElementsElementResultsResult : allResultsNode)
{
@@ -58,6 +60,8 @@ void DetectLivingFaceResult::parse(const std::string &payload)
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Rate"].isNull())
resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
if(!dataNodeElementsElementResultsResult["MessageTips"].isNull())
resultsObject.messageTips = dataNodeElementsElementResultsResult["MessageTips"].asString();
auto allFramesNode = dataNodeElementsElementResultsResult["Frames"]["Frame"];
for (auto dataNodeElementsElementResultsResultFramesFrame : allFramesNode)
{
@@ -68,6 +72,15 @@ void DetectLivingFaceResult::parse(const std::string &payload)
framesObject.rate = std::stof(dataNodeElementsElementResultsResultFramesFrame["Rate"].asString());
resultsObject.frames.push_back(framesObject);
}
auto rectNode = value["Rect"];
if(!rectNode["Left"].isNull())
resultsObject.rect.left = std::stol(rectNode["Left"].asString());
if(!rectNode["Top"].isNull())
resultsObject.rect.top = std::stol(rectNode["Top"].asString());
if(!rectNode["Width"].isNull())
resultsObject.rect.width = std::stol(rectNode["Width"].asString());
if(!rectNode["Height"].isNull())
resultsObject.rect.height = std::stol(rectNode["Height"].asString());
elementObject.results.push_back(resultsObject);
}
data_.elements.push_back(elementObject);

85
facebody/src/model/ExtractPedestrianFeatureAttributeRequest.cc
View File

@@ -1,85 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h>
using AlibabaCloud::Facebody::Model::ExtractPedestrianFeatureAttributeRequest;
ExtractPedestrianFeatureAttributeRequest::ExtractPedestrianFeatureAttributeRequest()
: RpcServiceRequest("facebody", "2019-12-30", "ExtractPedestrianFeatureAttribute") {
setMethod(HttpRequest::Method::Post);
}
ExtractPedestrianFeatureAttributeRequest::~ExtractPedestrianFeatureAttributeRequest() {}
bool ExtractPedestrianFeatureAttributeRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void ExtractPedestrianFeatureAttributeRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string ExtractPedestrianFeatureAttributeRequest::getMode() const {
return mode_;
}
void ExtractPedestrianFeatureAttributeRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
std::string ExtractPedestrianFeatureAttributeRequest::getOssFile() const {
return ossFile_;
}
void ExtractPedestrianFeatureAttributeRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::vector<ExtractPedestrianFeatureAttributeRequest::UrlList> ExtractPedestrianFeatureAttributeRequest::getUrlList() const {
return urlList_;
}
void ExtractPedestrianFeatureAttributeRequest::setUrlList(const std::vector<ExtractPedestrianFeatureAttributeRequest::UrlList> &urlList) {
urlList_ = urlList;
for(int dep1 = 0; dep1 != urlList.size(); dep1++) {
auto urlListObj = urlList.at(dep1);
std::string urlListObjStr = std::string("UrlList") + "." + std::to_string(dep1 + 1);
setBodyParameter(urlListObjStr + ".Url", urlListObj.url);
}
}
std::string ExtractPedestrianFeatureAttributeRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void ExtractPedestrianFeatureAttributeRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string ExtractPedestrianFeatureAttributeRequest::getImageURL() const {
return imageURL_;
}
void ExtractPedestrianFeatureAttributeRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

128
facebody/src/model/ExtractPedestrianFeatureAttributeResult.cc
View File

@@ -1,128 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/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["QualityScore"].isNull())
data_.qualityScore = std::stof(dataNode["QualityScore"].asString());
if(!dataNode["ObjType"].isNull())
data_.objType = dataNode["ObjType"].asString();
if(!dataNode["Feature"].isNull())
data_.feature = dataNode["Feature"].asString();
if(!dataNode["Gender"].isNull())
data_.gender = dataNode["Gender"].asString();
if(!dataNode["LowerColorScore"].isNull())
data_.lowerColorScore = std::stof(dataNode["LowerColorScore"].asString());
if(!dataNode["ObjTypeScore"].isNull())
data_.objTypeScore = std::stof(dataNode["ObjTypeScore"].asString());
if(!dataNode["Age"].isNull())
data_.age = dataNode["Age"].asString();
if(!dataNode["AgeScore"].isNull())
data_.ageScore = std::stof(dataNode["AgeScore"].asString());
if(!dataNode["UpperTypeScore"].isNull())
data_.upperTypeScore = std::stof(dataNode["UpperTypeScore"].asString());
if(!dataNode["LowerTypeScore"].isNull())
data_.lowerTypeScore = std::stof(dataNode["LowerTypeScore"].asString());
if(!dataNode["LowerColor"].isNull())
data_.lowerColor = dataNode["LowerColor"].asString();
if(!dataNode["Hair"].isNull())
data_.hair = dataNode["Hair"].asString();
if(!dataNode["UpperColor"].isNull())
data_.upperColor = dataNode["UpperColor"].asString();
if(!dataNode["GenderScore"].isNull())
data_.genderScore = std::stof(dataNode["GenderScore"].asString());
if(!dataNode["UpperType"].isNull())
data_.upperType = dataNode["UpperType"].asString();
if(!dataNode["HairScore"].isNull())
data_.hairScore = std::stof(dataNode["HairScore"].asString());
if(!dataNode["LowerType"].isNull())
data_.lowerType = dataNode["LowerType"].asString();
if(!dataNode["UpperColorScore"].isNull())
data_.upperColorScore = std::stof(dataNode["UpperColorScore"].asString());
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["QualityScore"].isNull())
elementObject.qualityScore = std::stof(dataNodeElementsElement["QualityScore"].asString());
if(!dataNodeElementsElement["ObjType"].isNull())
elementObject.objType = dataNodeElementsElement["ObjType"].asString();
if(!dataNodeElementsElement["Feature"].isNull())
elementObject.feature = dataNodeElementsElement["Feature"].asString();
if(!dataNodeElementsElement["Gender"].isNull())
elementObject.gender = dataNodeElementsElement["Gender"].asString();
if(!dataNodeElementsElement["LowerColorScore"].isNull())
elementObject.lowerColorScore = std::stof(dataNodeElementsElement["LowerColorScore"].asString());
if(!dataNodeElementsElement["ObjTypeScore"].isNull())
elementObject.objTypeScore = std::stof(dataNodeElementsElement["ObjTypeScore"].asString());
if(!dataNodeElementsElement["Age"].isNull())
elementObject.age = dataNodeElementsElement["Age"].asString();
if(!dataNodeElementsElement["AgeScore"].isNull())
elementObject.ageScore = std::stof(dataNodeElementsElement["AgeScore"].asString());
if(!dataNodeElementsElement["UpperTypeScore"].isNull())
elementObject.upperTypeScore = std::stof(dataNodeElementsElement["UpperTypeScore"].asString());
if(!dataNodeElementsElement["LowerTypeScore"].isNull())
elementObject.lowerTypeScore = std::stof(dataNodeElementsElement["LowerTypeScore"].asString());
if(!dataNodeElementsElement["LowerColor"].isNull())
elementObject.lowerColor = dataNodeElementsElement["LowerColor"].asString();
if(!dataNodeElementsElement["Hair"].isNull())
elementObject.hair = dataNodeElementsElement["Hair"].asString();
if(!dataNodeElementsElement["UpperColor"].isNull())
elementObject.upperColor = dataNodeElementsElement["UpperColor"].asString();
if(!dataNodeElementsElement["GenderScore"].isNull())
elementObject.genderScore = std::stof(dataNodeElementsElement["GenderScore"].asString());
if(!dataNodeElementsElement["UpperType"].isNull())
elementObject.upperType = dataNodeElementsElement["UpperType"].asString();
if(!dataNodeElementsElement["HairScore"].isNull())
elementObject.hairScore = std::stof(dataNodeElementsElement["HairScore"].asString());
if(!dataNodeElementsElement["LowerType"].isNull())
elementObject.lowerType = dataNodeElementsElement["LowerType"].asString();
if(!dataNodeElementsElement["UpperColorScore"].isNull())
elementObject.upperColorScore = std::stof(dataNodeElementsElement["UpperColorScore"].asString());
data_.elements.push_back(elementObject);
}
}
ExtractPedestrianFeatureAttributeResult::Data ExtractPedestrianFeatureAttributeResult::getData()const
{
return data_;
}