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 1999-2019 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/core/sts/StsRequest.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Sts;
StsRequest::StsRequest(const std::string &action)
: RpcServiceRequest("sts", "2015-04-01", action) {}
StsRequest::~StsRequest() {}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/sts/StsRequest.cc
|
C++
|
apache-2.0
| 874
|
/*
* Copyright 1999-2019 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/core/sts/model/AssumeRoleRequest.h>
// using namespace AlibabaCloud;
using namespace AlibabaCloud::Sts;
using namespace AlibabaCloud::Sts::Model;
AssumeRoleRequest::AssumeRoleRequest() : StsRequest("AssumeRole") {
setRoleArn("");
setRoleSessionName("");
setDurationSeconds(3600);
}
AssumeRoleRequest::~AssumeRoleRequest() {}
int AssumeRoleRequest::durationSeconds() const {
return std::stoi(parameter("DurationSeconds"));
}
std::string AssumeRoleRequest::policy() const { return parameter("Policy"); }
std::string AssumeRoleRequest::roleArn() const { return parameter("RoleArn"); }
std::string AssumeRoleRequest::roleSessionName() const {
return parameter("RoleSessionName");
}
void AssumeRoleRequest::setDurationSeconds(int durationSeconds) {
setParameter("DurationSeconds", std::to_string(durationSeconds));
}
void AssumeRoleRequest::setPolicy(const std::string &policy) {
setParameter("Policy", policy);
}
void AssumeRoleRequest::setRoleArn(const std::string &roleArn) {
setParameter("RoleArn", roleArn);
}
void AssumeRoleRequest::setRoleSessionName(const std::string &roleSessionName) {
setParameter("RoleSessionName", roleSessionName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/sts/model/AssumeRoleRequest.cc
|
C++
|
apache-2.0
| 1,820
|
/*
* Copyright 1999-2019 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/core/Utils.h>
#include <alibabacloud/core/sts/model/AssumeRoleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Sts;
using namespace AlibabaCloud::Sts::Model;
AssumeRoleResult::AssumeRoleResult()
: ServiceResult(), assumedRoleUser_(), credentials_() {}
AssumeRoleResult::AssumeRoleResult(const std::string &payload)
: ServiceResult(), assumedRoleUser_(), credentials_() {
parse(payload);
}
AssumeRoleResult::~AssumeRoleResult() {}
AssumeRoleResult::AssumedRoleUser AssumeRoleResult::assumedRoleUser() const {
return assumedRoleUser_;
}
AssumeRoleResult::Credentials AssumeRoleResult::credentials() const {
return credentials_;
}
void AssumeRoleResult::parse(const std::string &payload) {
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto assumedRoleUserNode = value["AssumedRoleUser"];
assumedRoleUser_.assumedRoleId =
assumedRoleUserNode["AssumedRoleId"].asString();
assumedRoleUser_.arn = assumedRoleUserNode["Arn"].asString();
auto credentialsNode = value["Credentials"];
credentials_.accessKeyId = credentialsNode["AccessKeyId"].asString();
credentials_.accessKeySecret = credentialsNode["AccessKeySecret"].asString();
credentials_.expiration = credentialsNode["Expiration"].asString();
credentials_.securityToken = credentialsNode["SecurityToken"].asString();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/sts/model/AssumeRoleResult.cc
|
C++
|
apache-2.0
| 2,052
|
/*
* Copyright 1999-2019 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/core/sts/model/GetCallerIdentityRequest.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Sts;
using namespace AlibabaCloud::Sts::Model;
GetCallerIdentityRequest::GetCallerIdentityRequest()
: StsRequest("GetCallerIdentity") {}
GetCallerIdentityRequest::~GetCallerIdentityRequest() {}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/sts/model/GetCallerIdentityRequest.cc
|
C++
|
apache-2.0
| 952
|
/*
* Copyright 1999-2019 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/core/Utils.h>
#include <alibabacloud/core/sts/model/GetCallerIdentityResult.h>
#include <json/json.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Sts;
using namespace AlibabaCloud::Sts::Model;
GetCallerIdentityResult::GetCallerIdentityResult()
: ServiceResult(), accountId_(), arn_(), userId_() {}
GetCallerIdentityResult::GetCallerIdentityResult(const std::string &payload)
: ServiceResult(), accountId_(), arn_(), userId_() {
parse(payload);
}
GetCallerIdentityResult::~GetCallerIdentityResult() {}
std::string GetCallerIdentityResult::accountId() { return accountId_; }
std::string GetCallerIdentityResult::arn() const { return arn_; }
std::string GetCallerIdentityResult::userId() const { return userId_; }
void GetCallerIdentityResult::parse(const std::string &payload) {
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
accountId_ = value["AccountId"].asString();
arn_ = value["Arn"].asString();
userId_ = value["UserId"].asString();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/sts/model/GetCallerIdentityResult.cc
|
C++
|
apache-2.0
| 1,706
|
/*
* Copyright 1999-2019 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/core/InstanceProfileCredentials.h>
namespace AlibabaCloud {
InstanceProfileCredentials::InstanceProfileCredentials()
: BasicSessionCredentials(Credentials::InstanceProfile) {}
InstanceProfileCredentials::~InstanceProfileCredentials() {}
} // namespace AlibabaCloud
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/core/src/unused/InstanceProfileCredentials.cc
|
C++
|
apache-2.0
| 921
|
#!/bin/bash
product=$1
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
rm -rf sdk_build
mkdir sdk_build
cd sdk_build
cmake -DBUILD_PRODUCT="$product" -DBUILD_FUNCTION_TESTS=OFF -DBUILD_UNIT_TESTS=OFF -DENABLE_COVERAGE=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ..
$MAKE
make install
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/easyinstall.sh
|
Shell
|
apache-2.0
| 409
|
cmake_minimum_required(VERSION 3.1)
cmake_policy(SET CMP0048 NEW)
project(alibabacloud-sdk-examples)
set(CMAKE_CXX_STANDARD 11)
add_subdirectory(imagesearch)
add_subdirectory(nlp)
add_subdirectory(rds)
add_subdirectory(ecs)
add_subdirectory(vpc)
add_subdirectory(slb)
add_subdirectory(cdn)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/CMakeLists.txt
|
CMake
|
apache-2.0
| 294
|
#include <iostream>
#include "../utils.h"
#include "alibabacloud/core/AlibabaCloud.h"
#include "alibabacloud/facebody/FacebodyClient.h"
#include "alibabacloud/core/CommonClient.h"
using namespace std;
using namespace AlibabaCloud;
using namespace AlibabaCloud::Facebody;
int main() {
utUtils utils;
string key = "Your-Access-Key";
string secret = "Your-Access-Secret";
InitializeSdk();
ClientConfiguration configuration("cn-shanghai");
configuration.setEndpoint("facebody.cn-shanghai.aliyuncs.com");
FacebodyClient client(key, secret, configuration);
Model::CompareFaceRequest request;
request.setMethod(HttpRequest::Method::Post);
request.setImageURLA("https://aibox-train-bucket.oss-cn-shanghai.aliyuncs.com/face/9_Press_Conference_Press_Conference_9_472.jpg?Expires=1608266970&OSSAccessKeyId=TMP.3Kdiw8VbXJ4JEYeZxcdf6DsDE2H43Q4QgiJKreabL6Mkym1JAgJvkapV3HPKq4jjvnALNUefBbzgGF5qJjoh4u2G2YbHhp&Signature=CL8WSF75gzeaAzWub%2BXw9nYxgaE%3D&versionId=CAEQEhiBgIDen.7PsxciIDlhYjQwMmMzZWJjZjQzYTQ4OGVlMGIyN2NlZWZjNTcw&response-content-type=application%2Foctet-stream");
request.setImageURLB("https://aibox-train-bucket.oss-cn-shanghai.aliyuncs.com/face/9_Press_Conference_Press_Conference_9_472.jpg?Expires=1608266970&OSSAccessKeyId=TMP.3Kdiw8VbXJ4JEYeZxcdf6DsDE2H43Q4QgiJKreabL6Mkym1JAgJvkapV3HPKq4jjvnALNUefBbzgGF5qJjoh4u2G2YbHhp&Signature=CL8WSF75gzeaAzWub%2BXw9nYxgaE%3D&versionId=CAEQEhiBgIDen.7PsxciIDlhYjQwMmMzZWJjZjQzYTQ4OGVlMGIyN2NlZWZjNTcw&response-content-type=application%2Foctet-stream");
auto outcome = client.compareFace(request);
cout << endl << "facebody describeInstances returned:" << endl;
cout << "error code: " << outcome.error().errorCode() << endl;
cout << "requestId: " << outcome.result().requestId() << endl << endl;
cout << outcome.result().getData().confidence << endl;
cout << outcome.result().getData().rectAList[0] << endl;
cout << outcome.result().getData().rectAList[1] << endl;
cout << outcome.result().getData().rectAList[2] << endl;
cout << outcome.result().getData().rectAList[3] << endl;
ShutdownSdk();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/facebody/facebody.cc
|
C++
|
apache-2.0
| 2,130
|
cmake_minimum_required(VERSION 3.0)
project(imagesearch_demo)
set(CMAKE_CXX_STANDARD 11)
if(CMAKE_HOST_WIN32)
include_directories("C:\\Program Files (x86)\\alibabacloud-sdk\\include")
link_directories("C:\\Program Files (x86)\\alibabacloud-sdk\\lib")
endif()
add_executable(imagesearch_demo imagesearch.cc)
target_link_libraries(imagesearch_demo alibabacloud-sdk-core)
target_link_libraries(imagesearch_demo )
set_target_properties(imagesearch_demo
PROPERTIES
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}imagesearch_demo
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
file(COPY 1.jpg 2.jpg DESTINATION ${CMAKE_BINARY_DIR}/bin)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/imagesearch/CMakeLists.txt
|
CMake
|
apache-2.0
| 643
|
#include <map>
#include <sstream>
#include <iostream>
#include "../utils.h"
#include "alibabacloud/core/AlibabaCloud.h"
#include "alibabacloud/core/CommonClient.h"
using namespace std;
using namespace AlibabaCloud;
typedef unsigned char u8_t;
const string catId = "88888888"; // ref: https://help.aliyun.com/document_detail/66623.html
const string itemId = "1234";
string custContent = "{\"key\":\"value\"}";
map<string, string> picList;
map<int, string> mapStudent;
const string jpg1 = "1.jpg";
const string jpg2 = "2.jpg";
static const u8_t base64_table[65] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/**
* base64_encode - Base64 encode
* @src: Data to be encoded
* @len: Length of the data to be encoded
* @out_len: Pointer to output length variable, or %NULL if not used
* Returns: Allocated buffer of out_len bytes of encoded data,
* or empty string on failure
*/
string base64_encode(const unsigned char *src, size_t len) {
unsigned char *out, *pos;
const unsigned char *end, *in;
size_t olen;
olen = 4*((len + 2) / 3); /* 3-byte blocks to 4-byte */
if (olen < len)
return std::string(); /* integer overflow */
std::string outStr;
outStr.resize(olen);
out = (unsigned char*)&outStr[0];
end = src + len;
in = src;
pos = out;
while (end - in >= 3) {
*pos++ = base64_table[in[0] >> 2];
*pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)];
*pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)];
*pos++ = base64_table[in[2] & 0x3f];
in += 3;
}
if (end - in) {
*pos++ = base64_table[in[0] >> 2];
if (end - in == 1) {
*pos++ = base64_table[(in[0] & 0x03) << 4];
*pos++ = '=';
}
else {
*pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)];
*pos++ = base64_table[(in[1] & 0x0f) << 2];
}
*pos++ = '=';
}
return outStr;
}
string imageBase64(string file) {
FILE* img = nullptr;
#ifdef _WIN32
fopen_s(&img, file.c_str(), "rb");
#else
img = fopen(file.c_str(), "rb");
#endif
if (!img) {
perror("open file error");
return "";
}
fseek(img, 0L, SEEK_END);
int size = ftell(img);
fseek(img, 0L, SEEK_SET);
u8_t* buf = (u8_t*)malloc(size);
int bytes = fread(buf, 1, size, img);
fclose(img);
string encoded = base64_encode(buf, bytes);
free(buf);
return encoded;
}
string buildContent(map<string, string> params) {
string meta = "";
string body = "";
int start = 0;
for(auto item = params.begin(); item != params.end(); item++) {
auto k = item->first;
auto v = item->second;
if (meta.size() > 0) {
meta += "#";
}
std::stringstream ss1, ss2;
ss1 << start;
ss2 << start + v.size();
meta += k + "," + ss1.str() + "," + ss2.str();
body += v;
start += v.size();
}
return meta + "^" + body;
}
string buildAddContent(map<string, string> picList) {
if (itemId.empty() || catId.empty() ) {
return "";
}
if (custContent.empty()) {
custContent = "";
}
map<string, string> params;
params["item_id"] = itemId;
params["cat_id"] = catId;
params["cust_content"] = custContent;
string picListStr = "";
for (auto item = picList.begin(); item != picList.end(); item++) {
auto v = item->second;
auto k = item->first;
if (k.empty()) {
continue;
}
picListStr += k + ",";
params[k] = v;
}
params["pic_list"] = picListStr.substr(0, picListStr.size() - 1);
return buildContent(params);
}
int main(int argc, char** argv) {
utUtils utils;
string key = utils.get_env("ENV_AccessKeyId");
string secret = utils.get_env("ENV_AccessKeySecret");
InitializeSdk();
ClientConfiguration configuration("cn-shanghai");
CommonClient client(key, secret, configuration);
CommonRequest request(CommonRequest::RoaPattern);
request.setScheme("http");
request.setDomain("imagesearch.cn-shanghai.aliyuncs.com");
request.setResourcePath("/item/add");
request.setHeaderParameter("instanceName", "sdkimagetest1");
request.setHttpMethod(HttpRequest::Post);
char dir[1024];
utils.get_dir_exec(dir, nullptr);
#ifdef _WIN32
// windows binary has an extra Release/Debug/... dir
string image1_path = string(dir) + "\\..\\1.jpg";
string image2_path = string(dir) + "\\..\\2.jpg";
#else
string image1_path = string(dir) + "1.jpg";
string image2_path = string(dir) + "2.jpg";
#endif
picList[base64_encode((u8_t*)jpg1.c_str(), jpg1.size())] = imageBase64(image1_path);
picList[base64_encode((u8_t*)jpg2.c_str(), jpg2.size())] = imageBase64(image2_path);
string cc = buildAddContent(picList);
const char* data = cc.c_str();
request.setContent(cc.c_str(), cc.size());
request.setHeaderParameter("Content-Type", "application/octet-stream;charset=utf-8");
request.setHeaderParameter("Accept", "application/json");
request.setVersion("2018-01-20");
auto out = client.commonResponse(request);
if (!out.isSuccess()) {
cout << "error code: " << out.error().errorCode() << endl;
cout << "error message: " << out.error().errorMessage() << endl;
cout << "error host: " << out.error().host() << endl;
cout << "error requestId: " << out.error().requestId() << endl;
cout << "error detail: " << out.error().detail() << endl;
ShutdownSdk();
return -1;
}
cout << endl << "add item returns: " << out.result().payload() << endl << endl;
ShutdownSdk();
return 0;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/imagesearch/imagesearch.cc
|
C++
|
apache-2.0
| 5,431
|
cmake_minimum_required(VERSION 3.0)
project(nlp_demo)
set(CMAKE_CXX_STANDARD 11)
if(CMAKE_HOST_WIN32)
include_directories("C:\\Program Files (x86)\\alibabacloud-sdk\\include")
link_directories("C:\\Program Files (x86)\\alibabacloud-sdk\\lib")
endif()
add_executable(nlp_demo nlp.cc)
target_link_libraries(nlp_demo alibabacloud-sdk-core)
target_link_libraries(nlp_demo )
set_target_properties(nlp_demo
PROPERTIES
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}nlp_demo
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/nlp/CMakeLists.txt
|
CMake
|
apache-2.0
| 528
|
#include <iostream>
#include <cstdlib>
#include <cstring>
#include "../utils.h"
#include "alibabacloud/core/AlibabaCloud.h"
#include "alibabacloud/core/CommonClient.h"
using namespace std;
using namespace AlibabaCloud;
int main(int argc, char** argv) {
utUtils utils;
string key = utils.get_env("ENV_AccessKeyId");
string secret = utils.get_env("ENV_AccessKeySecret");
InitializeSdk();
ClientConfiguration configuration("cn-shanghai");
CommonClient client(key, secret, configuration);
CommonRequest request(CommonRequest::RoaPattern);
request.setScheme("http");
request.setDomain("nlp.cn-shanghai.aliyuncs.com");
request.setResourcePath("/nlp/api/wordsegment/general");
request.setHttpMethod(HttpRequest::Post);
// if windows, Chinese character will result in build error.
const std::string data = "{\"lang\":\"ZH\",\"text\":\"Iphone is a good choice.\"}";
request.setContent(data.c_str(), data.size());
request.setHeaderParameter("Content-Type", "application/json;chrset=utf-8");
request.setHeaderParameter("Accept", "application/json");
request.setVersion("2018-04-08");
auto out = client.commonResponse(request);
if (!out.isSuccess()) {
cout << "error code: " << out.error().errorCode() << endl;
cout << "error message: " << out.error().errorMessage() << endl;
cout << "error host: " << out.error().host() << endl;
cout << "error requestId: " << out.error().requestId() << endl;
cout << "error detail: " << out.error().detail() << endl;
ShutdownSdk();
return -1;
}
cout << endl << "wordsegment retruns: " << out.result().payload() << std::endl << endl;
ShutdownSdk();
return 0;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/nlp/nlp.cc
|
C++
|
apache-2.0
| 1,680
|
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
class utUtils {
public:
void get_dir_exec(char* dir, char* exec) {
#ifdef _WIN32
char BufferFileName[MAX_PATH];
memset(BufferFileName,0,MAX_PATH);
if (GetModuleFileName(NULL, BufferFileName, MAX_PATH)) {
if (exec) {
snprintf(exec, strlen(BufferFileName), "%s", BufferFileName);
}
std::string ss(BufferFileName);
int idx = ss.find_last_of("\\");
BufferFileName[idx] = '\0';
snprintf(dir, strlen(BufferFileName), "%s", BufferFileName);
}
return;
#else
char* filename = nullptr;
if (readlink("/proc/self/exe", dir, 1024) < 0) {
dir[0] = '\0';
return;
}
filename = strrchr(dir, '/');
if (filename == nullptr) {
dir[0] = '\0';
return;
}
++filename;
if (exec) {
sprintf(exec, "%s", filename);
}
*filename = '\0';
return;
#endif
}
std::string get_env(const std::string env) {
#ifdef _WIN32
char* buf = nullptr;
size_t sz = 0;
if (_dupenv_s(&buf, &sz, env.c_str()) == 0 && buf != nullptr) {
std::string var(buf);
free(buf);
return var;
} else {
return std::string();
}
#else
char* value = getenv(env.c_str());
if (value == nullptr) {
return std::string();
}
return std::string(value);
#endif
}
};
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/examples/utils.h
|
C++
|
apache-2.0
| 1,400
|
#
# 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(facebody_public_header
include/alibabacloud/facebody/FacebodyClient.h
include/alibabacloud/facebody/FacebodyExport.h )
set(facebody_public_header_model
include/alibabacloud/facebody/model/AddFaceRequest.h
include/alibabacloud/facebody/model/AddFaceResult.h
include/alibabacloud/facebody/model/AddFaceEntityRequest.h
include/alibabacloud/facebody/model/AddFaceEntityResult.h
include/alibabacloud/facebody/model/BlurFaceRequest.h
include/alibabacloud/facebody/model/BlurFaceResult.h
include/alibabacloud/facebody/model/BodyPostureRequest.h
include/alibabacloud/facebody/model/BodyPostureResult.h
include/alibabacloud/facebody/model/CompareFaceRequest.h
include/alibabacloud/facebody/model/CompareFaceResult.h
include/alibabacloud/facebody/model/CountCrowdRequest.h
include/alibabacloud/facebody/model/CountCrowdResult.h
include/alibabacloud/facebody/model/CreateFaceDbRequest.h
include/alibabacloud/facebody/model/CreateFaceDbResult.h
include/alibabacloud/facebody/model/DeleteFaceRequest.h
include/alibabacloud/facebody/model/DeleteFaceResult.h
include/alibabacloud/facebody/model/DeleteFaceDbRequest.h
include/alibabacloud/facebody/model/DeleteFaceDbResult.h
include/alibabacloud/facebody/model/DeleteFaceEntityRequest.h
include/alibabacloud/facebody/model/DeleteFaceEntityResult.h
include/alibabacloud/facebody/model/DetectBodyCountRequest.h
include/alibabacloud/facebody/model/DetectBodyCountResult.h
include/alibabacloud/facebody/model/DetectCelebrityRequest.h
include/alibabacloud/facebody/model/DetectCelebrityResult.h
include/alibabacloud/facebody/model/DetectChefCapRequest.h
include/alibabacloud/facebody/model/DetectChefCapResult.h
include/alibabacloud/facebody/model/DetectFaceRequest.h
include/alibabacloud/facebody/model/DetectFaceResult.h
include/alibabacloud/facebody/model/DetectIPCPedestrianRequest.h
include/alibabacloud/facebody/model/DetectIPCPedestrianResult.h
include/alibabacloud/facebody/model/DetectLivingFaceRequest.h
include/alibabacloud/facebody/model/DetectLivingFaceResult.h
include/alibabacloud/facebody/model/DetectMaskRequest.h
include/alibabacloud/facebody/model/DetectMaskResult.h
include/alibabacloud/facebody/model/DetectPedestrianRequest.h
include/alibabacloud/facebody/model/DetectPedestrianResult.h
include/alibabacloud/facebody/model/DetectVideoLivingFaceRequest.h
include/alibabacloud/facebody/model/DetectVideoLivingFaceResult.h
include/alibabacloud/facebody/model/EnhanceFaceRequest.h
include/alibabacloud/facebody/model/EnhanceFaceResult.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
include/alibabacloud/facebody/model/FaceFilterResult.h
include/alibabacloud/facebody/model/FaceMakeupRequest.h
include/alibabacloud/facebody/model/FaceMakeupResult.h
include/alibabacloud/facebody/model/FaceTidyupRequest.h
include/alibabacloud/facebody/model/FaceTidyupResult.h
include/alibabacloud/facebody/model/GenerateHumanAnimeStyleRequest.h
include/alibabacloud/facebody/model/GenerateHumanAnimeStyleResult.h
include/alibabacloud/facebody/model/GetFaceEntityRequest.h
include/alibabacloud/facebody/model/GetFaceEntityResult.h
include/alibabacloud/facebody/model/HandPostureRequest.h
include/alibabacloud/facebody/model/HandPostureResult.h
include/alibabacloud/facebody/model/ListFaceDbsRequest.h
include/alibabacloud/facebody/model/ListFaceDbsResult.h
include/alibabacloud/facebody/model/ListFaceEntitiesRequest.h
include/alibabacloud/facebody/model/ListFaceEntitiesResult.h
include/alibabacloud/facebody/model/PedestrianDetectAttributeRequest.h
include/alibabacloud/facebody/model/PedestrianDetectAttributeResult.h
include/alibabacloud/facebody/model/RecognizeActionRequest.h
include/alibabacloud/facebody/model/RecognizeActionResult.h
include/alibabacloud/facebody/model/RecognizeExpressionRequest.h
include/alibabacloud/facebody/model/RecognizeExpressionResult.h
include/alibabacloud/facebody/model/RecognizeFaceRequest.h
include/alibabacloud/facebody/model/RecognizeFaceResult.h
include/alibabacloud/facebody/model/RecognizePublicFaceRequest.h
include/alibabacloud/facebody/model/RecognizePublicFaceResult.h
include/alibabacloud/facebody/model/SearchFaceRequest.h
include/alibabacloud/facebody/model/SearchFaceResult.h
include/alibabacloud/facebody/model/SwapFacialFeaturesRequest.h
include/alibabacloud/facebody/model/SwapFacialFeaturesResult.h
include/alibabacloud/facebody/model/UpdateFaceEntityRequest.h
include/alibabacloud/facebody/model/UpdateFaceEntityResult.h
include/alibabacloud/facebody/model/VerifyFaceMaskRequest.h
include/alibabacloud/facebody/model/VerifyFaceMaskResult.h )
set(facebody_src
src/FacebodyClient.cc
src/model/AddFaceRequest.cc
src/model/AddFaceResult.cc
src/model/AddFaceEntityRequest.cc
src/model/AddFaceEntityResult.cc
src/model/BlurFaceRequest.cc
src/model/BlurFaceResult.cc
src/model/BodyPostureRequest.cc
src/model/BodyPostureResult.cc
src/model/CompareFaceRequest.cc
src/model/CompareFaceResult.cc
src/model/CountCrowdRequest.cc
src/model/CountCrowdResult.cc
src/model/CreateFaceDbRequest.cc
src/model/CreateFaceDbResult.cc
src/model/DeleteFaceRequest.cc
src/model/DeleteFaceResult.cc
src/model/DeleteFaceDbRequest.cc
src/model/DeleteFaceDbResult.cc
src/model/DeleteFaceEntityRequest.cc
src/model/DeleteFaceEntityResult.cc
src/model/DetectBodyCountRequest.cc
src/model/DetectBodyCountResult.cc
src/model/DetectCelebrityRequest.cc
src/model/DetectCelebrityResult.cc
src/model/DetectChefCapRequest.cc
src/model/DetectChefCapResult.cc
src/model/DetectFaceRequest.cc
src/model/DetectFaceResult.cc
src/model/DetectIPCPedestrianRequest.cc
src/model/DetectIPCPedestrianResult.cc
src/model/DetectLivingFaceRequest.cc
src/model/DetectLivingFaceResult.cc
src/model/DetectMaskRequest.cc
src/model/DetectMaskResult.cc
src/model/DetectPedestrianRequest.cc
src/model/DetectPedestrianResult.cc
src/model/DetectVideoLivingFaceRequest.cc
src/model/DetectVideoLivingFaceResult.cc
src/model/EnhanceFaceRequest.cc
src/model/EnhanceFaceResult.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
src/model/FaceFilterResult.cc
src/model/FaceMakeupRequest.cc
src/model/FaceMakeupResult.cc
src/model/FaceTidyupRequest.cc
src/model/FaceTidyupResult.cc
src/model/GenerateHumanAnimeStyleRequest.cc
src/model/GenerateHumanAnimeStyleResult.cc
src/model/GetFaceEntityRequest.cc
src/model/GetFaceEntityResult.cc
src/model/HandPostureRequest.cc
src/model/HandPostureResult.cc
src/model/ListFaceDbsRequest.cc
src/model/ListFaceDbsResult.cc
src/model/ListFaceEntitiesRequest.cc
src/model/ListFaceEntitiesResult.cc
src/model/PedestrianDetectAttributeRequest.cc
src/model/PedestrianDetectAttributeResult.cc
src/model/RecognizeActionRequest.cc
src/model/RecognizeActionResult.cc
src/model/RecognizeExpressionRequest.cc
src/model/RecognizeExpressionResult.cc
src/model/RecognizeFaceRequest.cc
src/model/RecognizeFaceResult.cc
src/model/RecognizePublicFaceRequest.cc
src/model/RecognizePublicFaceResult.cc
src/model/SearchFaceRequest.cc
src/model/SearchFaceResult.cc
src/model/SwapFacialFeaturesRequest.cc
src/model/SwapFacialFeaturesResult.cc
src/model/UpdateFaceEntityRequest.cc
src/model/UpdateFaceEntityResult.cc
src/model/VerifyFaceMaskRequest.cc
src/model/VerifyFaceMaskResult.cc )
add_library(facebody ${LIB_TYPE}
${facebody_public_header}
${facebody_public_header_model}
${facebody_src})
set_target_properties(facebody
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}facebody
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(facebody
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_FACEBODY_LIBRARY)
endif()
target_include_directories(facebody
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(facebody
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(facebody
jsoncpp)
target_include_directories(facebody
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(facebody
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(facebody
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(facebody
PRIVATE /usr/include/jsoncpp)
target_link_libraries(facebody
jsoncpp)
endif()
install(FILES ${facebody_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/facebody)
install(FILES ${facebody_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/facebody/model)
install(TARGETS facebody
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/facebody/CMakeLists.txt
|
CMake
|
apache-2.0
| 10,183
|
/*
* 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_FACEBODYCLIENT_H_
#define ALIBABACLOUD_FACEBODY_FACEBODYCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "FacebodyExport.h"
#include "model/AddFaceRequest.h"
#include "model/AddFaceResult.h"
#include "model/AddFaceEntityRequest.h"
#include "model/AddFaceEntityResult.h"
#include "model/BlurFaceRequest.h"
#include "model/BlurFaceResult.h"
#include "model/BodyPostureRequest.h"
#include "model/BodyPostureResult.h"
#include "model/CompareFaceRequest.h"
#include "model/CompareFaceResult.h"
#include "model/CountCrowdRequest.h"
#include "model/CountCrowdResult.h"
#include "model/CreateFaceDbRequest.h"
#include "model/CreateFaceDbResult.h"
#include "model/DeleteFaceRequest.h"
#include "model/DeleteFaceResult.h"
#include "model/DeleteFaceDbRequest.h"
#include "model/DeleteFaceDbResult.h"
#include "model/DeleteFaceEntityRequest.h"
#include "model/DeleteFaceEntityResult.h"
#include "model/DetectBodyCountRequest.h"
#include "model/DetectBodyCountResult.h"
#include "model/DetectCelebrityRequest.h"
#include "model/DetectCelebrityResult.h"
#include "model/DetectChefCapRequest.h"
#include "model/DetectChefCapResult.h"
#include "model/DetectFaceRequest.h"
#include "model/DetectFaceResult.h"
#include "model/DetectIPCPedestrianRequest.h"
#include "model/DetectIPCPedestrianResult.h"
#include "model/DetectLivingFaceRequest.h"
#include "model/DetectLivingFaceResult.h"
#include "model/DetectMaskRequest.h"
#include "model/DetectMaskResult.h"
#include "model/DetectPedestrianRequest.h"
#include "model/DetectPedestrianResult.h"
#include "model/DetectVideoLivingFaceRequest.h"
#include "model/DetectVideoLivingFaceResult.h"
#include "model/EnhanceFaceRequest.h"
#include "model/EnhanceFaceResult.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"
#include "model/FaceFilterResult.h"
#include "model/FaceMakeupRequest.h"
#include "model/FaceMakeupResult.h"
#include "model/FaceTidyupRequest.h"
#include "model/FaceTidyupResult.h"
#include "model/GenerateHumanAnimeStyleRequest.h"
#include "model/GenerateHumanAnimeStyleResult.h"
#include "model/GetFaceEntityRequest.h"
#include "model/GetFaceEntityResult.h"
#include "model/HandPostureRequest.h"
#include "model/HandPostureResult.h"
#include "model/ListFaceDbsRequest.h"
#include "model/ListFaceDbsResult.h"
#include "model/ListFaceEntitiesRequest.h"
#include "model/ListFaceEntitiesResult.h"
#include "model/PedestrianDetectAttributeRequest.h"
#include "model/PedestrianDetectAttributeResult.h"
#include "model/RecognizeActionRequest.h"
#include "model/RecognizeActionResult.h"
#include "model/RecognizeExpressionRequest.h"
#include "model/RecognizeExpressionResult.h"
#include "model/RecognizeFaceRequest.h"
#include "model/RecognizeFaceResult.h"
#include "model/RecognizePublicFaceRequest.h"
#include "model/RecognizePublicFaceResult.h"
#include "model/SearchFaceRequest.h"
#include "model/SearchFaceResult.h"
#include "model/SwapFacialFeaturesRequest.h"
#include "model/SwapFacialFeaturesResult.h"
#include "model/UpdateFaceEntityRequest.h"
#include "model/UpdateFaceEntityResult.h"
#include "model/VerifyFaceMaskRequest.h"
#include "model/VerifyFaceMaskResult.h"
namespace AlibabaCloud
{
namespace Facebody
{
class ALIBABACLOUD_FACEBODY_EXPORT FacebodyClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddFaceResult> AddFaceOutcome;
typedef std::future<AddFaceOutcome> AddFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::AddFaceRequest&, const AddFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFaceAsyncHandler;
typedef Outcome<Error, Model::AddFaceEntityResult> AddFaceEntityOutcome;
typedef std::future<AddFaceEntityOutcome> AddFaceEntityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::AddFaceEntityRequest&, const AddFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFaceEntityAsyncHandler;
typedef Outcome<Error, Model::BlurFaceResult> BlurFaceOutcome;
typedef std::future<BlurFaceOutcome> BlurFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::BlurFaceRequest&, const BlurFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BlurFaceAsyncHandler;
typedef Outcome<Error, Model::BodyPostureResult> BodyPostureOutcome;
typedef std::future<BodyPostureOutcome> BodyPostureOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::BodyPostureRequest&, const BodyPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BodyPostureAsyncHandler;
typedef Outcome<Error, Model::CompareFaceResult> CompareFaceOutcome;
typedef std::future<CompareFaceOutcome> CompareFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CompareFaceRequest&, const CompareFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareFaceAsyncHandler;
typedef Outcome<Error, Model::CountCrowdResult> CountCrowdOutcome;
typedef std::future<CountCrowdOutcome> CountCrowdOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CountCrowdRequest&, const CountCrowdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CountCrowdAsyncHandler;
typedef Outcome<Error, Model::CreateFaceDbResult> CreateFaceDbOutcome;
typedef std::future<CreateFaceDbOutcome> CreateFaceDbOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::CreateFaceDbRequest&, const CreateFaceDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceDbAsyncHandler;
typedef Outcome<Error, Model::DeleteFaceResult> DeleteFaceOutcome;
typedef std::future<DeleteFaceOutcome> DeleteFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceRequest&, const DeleteFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceAsyncHandler;
typedef Outcome<Error, Model::DeleteFaceDbResult> DeleteFaceDbOutcome;
typedef std::future<DeleteFaceDbOutcome> DeleteFaceDbOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceDbRequest&, const DeleteFaceDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceDbAsyncHandler;
typedef Outcome<Error, Model::DeleteFaceEntityResult> DeleteFaceEntityOutcome;
typedef std::future<DeleteFaceEntityOutcome> DeleteFaceEntityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceEntityRequest&, const DeleteFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceEntityAsyncHandler;
typedef Outcome<Error, Model::DetectBodyCountResult> DetectBodyCountOutcome;
typedef std::future<DetectBodyCountOutcome> DetectBodyCountOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectBodyCountRequest&, const DetectBodyCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectBodyCountAsyncHandler;
typedef Outcome<Error, Model::DetectCelebrityResult> DetectCelebrityOutcome;
typedef std::future<DetectCelebrityOutcome> DetectCelebrityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectCelebrityRequest&, const DetectCelebrityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCelebrityAsyncHandler;
typedef Outcome<Error, Model::DetectChefCapResult> DetectChefCapOutcome;
typedef std::future<DetectChefCapOutcome> DetectChefCapOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectChefCapRequest&, const DetectChefCapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectChefCapAsyncHandler;
typedef Outcome<Error, Model::DetectFaceResult> DetectFaceOutcome;
typedef std::future<DetectFaceOutcome> DetectFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectFaceRequest&, const DetectFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectFaceAsyncHandler;
typedef Outcome<Error, Model::DetectIPCPedestrianResult> DetectIPCPedestrianOutcome;
typedef std::future<DetectIPCPedestrianOutcome> DetectIPCPedestrianOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectIPCPedestrianRequest&, const DetectIPCPedestrianOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectIPCPedestrianAsyncHandler;
typedef Outcome<Error, Model::DetectLivingFaceResult> DetectLivingFaceOutcome;
typedef std::future<DetectLivingFaceOutcome> DetectLivingFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectLivingFaceRequest&, const DetectLivingFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLivingFaceAsyncHandler;
typedef Outcome<Error, Model::DetectMaskResult> DetectMaskOutcome;
typedef std::future<DetectMaskOutcome> DetectMaskOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectMaskRequest&, const DetectMaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectMaskAsyncHandler;
typedef Outcome<Error, Model::DetectPedestrianResult> DetectPedestrianOutcome;
typedef std::future<DetectPedestrianOutcome> DetectPedestrianOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectPedestrianRequest&, const DetectPedestrianOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectPedestrianAsyncHandler;
typedef Outcome<Error, Model::DetectVideoLivingFaceResult> DetectVideoLivingFaceOutcome;
typedef std::future<DetectVideoLivingFaceOutcome> DetectVideoLivingFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DetectVideoLivingFaceRequest&, const DetectVideoLivingFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVideoLivingFaceAsyncHandler;
typedef Outcome<Error, Model::EnhanceFaceResult> EnhanceFaceOutcome;
typedef std::future<EnhanceFaceOutcome> EnhanceFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::EnhanceFaceRequest&, const EnhanceFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceFaceAsyncHandler;
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;
typedef Outcome<Error, Model::FaceFilterResult> FaceFilterOutcome;
typedef std::future<FaceFilterOutcome> FaceFilterOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::FaceFilterRequest&, const FaceFilterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceFilterAsyncHandler;
typedef Outcome<Error, Model::FaceMakeupResult> FaceMakeupOutcome;
typedef std::future<FaceMakeupOutcome> FaceMakeupOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::FaceMakeupRequest&, const FaceMakeupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceMakeupAsyncHandler;
typedef Outcome<Error, Model::FaceTidyupResult> FaceTidyupOutcome;
typedef std::future<FaceTidyupOutcome> FaceTidyupOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::FaceTidyupRequest&, const FaceTidyupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceTidyupAsyncHandler;
typedef Outcome<Error, Model::GenerateHumanAnimeStyleResult> GenerateHumanAnimeStyleOutcome;
typedef std::future<GenerateHumanAnimeStyleOutcome> GenerateHumanAnimeStyleOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GenerateHumanAnimeStyleRequest&, const GenerateHumanAnimeStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateHumanAnimeStyleAsyncHandler;
typedef Outcome<Error, Model::GetFaceEntityResult> GetFaceEntityOutcome;
typedef std::future<GetFaceEntityOutcome> GetFaceEntityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::GetFaceEntityRequest&, const GetFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceEntityAsyncHandler;
typedef Outcome<Error, Model::HandPostureResult> HandPostureOutcome;
typedef std::future<HandPostureOutcome> HandPostureOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::HandPostureRequest&, const HandPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HandPostureAsyncHandler;
typedef Outcome<Error, Model::ListFaceDbsResult> ListFaceDbsOutcome;
typedef std::future<ListFaceDbsOutcome> ListFaceDbsOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ListFaceDbsRequest&, const ListFaceDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceDbsAsyncHandler;
typedef Outcome<Error, Model::ListFaceEntitiesResult> ListFaceEntitiesOutcome;
typedef std::future<ListFaceEntitiesOutcome> ListFaceEntitiesOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::ListFaceEntitiesRequest&, const ListFaceEntitiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceEntitiesAsyncHandler;
typedef Outcome<Error, Model::PedestrianDetectAttributeResult> PedestrianDetectAttributeOutcome;
typedef std::future<PedestrianDetectAttributeOutcome> PedestrianDetectAttributeOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::PedestrianDetectAttributeRequest&, const PedestrianDetectAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PedestrianDetectAttributeAsyncHandler;
typedef Outcome<Error, Model::RecognizeActionResult> RecognizeActionOutcome;
typedef std::future<RecognizeActionOutcome> RecognizeActionOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::RecognizeActionRequest&, const RecognizeActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeActionAsyncHandler;
typedef Outcome<Error, Model::RecognizeExpressionResult> RecognizeExpressionOutcome;
typedef std::future<RecognizeExpressionOutcome> RecognizeExpressionOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::RecognizeExpressionRequest&, const RecognizeExpressionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeExpressionAsyncHandler;
typedef Outcome<Error, Model::RecognizeFaceResult> RecognizeFaceOutcome;
typedef std::future<RecognizeFaceOutcome> RecognizeFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::RecognizeFaceRequest&, const RecognizeFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeFaceAsyncHandler;
typedef Outcome<Error, Model::RecognizePublicFaceResult> RecognizePublicFaceOutcome;
typedef std::future<RecognizePublicFaceOutcome> RecognizePublicFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::RecognizePublicFaceRequest&, const RecognizePublicFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePublicFaceAsyncHandler;
typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
typedef Outcome<Error, Model::SwapFacialFeaturesResult> SwapFacialFeaturesOutcome;
typedef std::future<SwapFacialFeaturesOutcome> SwapFacialFeaturesOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::SwapFacialFeaturesRequest&, const SwapFacialFeaturesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwapFacialFeaturesAsyncHandler;
typedef Outcome<Error, Model::UpdateFaceEntityResult> UpdateFaceEntityOutcome;
typedef std::future<UpdateFaceEntityOutcome> UpdateFaceEntityOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::UpdateFaceEntityRequest&, const UpdateFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFaceEntityAsyncHandler;
typedef Outcome<Error, Model::VerifyFaceMaskResult> VerifyFaceMaskOutcome;
typedef std::future<VerifyFaceMaskOutcome> VerifyFaceMaskOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::VerifyFaceMaskRequest&, const VerifyFaceMaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyFaceMaskAsyncHandler;
FacebodyClient(const Credentials &credentials, const ClientConfiguration &configuration);
FacebodyClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
FacebodyClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~FacebodyClient();
AddFaceOutcome addFace(const Model::AddFaceRequest &request)const;
void addFaceAsync(const Model::AddFaceRequest& request, const AddFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddFaceOutcomeCallable addFaceCallable(const Model::AddFaceRequest& request) const;
AddFaceEntityOutcome addFaceEntity(const Model::AddFaceEntityRequest &request)const;
void addFaceEntityAsync(const Model::AddFaceEntityRequest& request, const AddFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddFaceEntityOutcomeCallable addFaceEntityCallable(const Model::AddFaceEntityRequest& request) const;
BlurFaceOutcome blurFace(const Model::BlurFaceRequest &request)const;
void blurFaceAsync(const Model::BlurFaceRequest& request, const BlurFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BlurFaceOutcomeCallable blurFaceCallable(const Model::BlurFaceRequest& request) const;
BodyPostureOutcome bodyPosture(const Model::BodyPostureRequest &request)const;
void bodyPostureAsync(const Model::BodyPostureRequest& request, const BodyPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BodyPostureOutcomeCallable bodyPostureCallable(const Model::BodyPostureRequest& request) const;
CompareFaceOutcome compareFace(const Model::CompareFaceRequest &request)const;
void compareFaceAsync(const Model::CompareFaceRequest& request, const CompareFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CompareFaceOutcomeCallable compareFaceCallable(const Model::CompareFaceRequest& request) const;
CountCrowdOutcome countCrowd(const Model::CountCrowdRequest &request)const;
void countCrowdAsync(const Model::CountCrowdRequest& request, const CountCrowdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CountCrowdOutcomeCallable countCrowdCallable(const Model::CountCrowdRequest& request) const;
CreateFaceDbOutcome createFaceDb(const Model::CreateFaceDbRequest &request)const;
void createFaceDbAsync(const Model::CreateFaceDbRequest& request, const CreateFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateFaceDbOutcomeCallable createFaceDbCallable(const Model::CreateFaceDbRequest& request) const;
DeleteFaceOutcome deleteFace(const Model::DeleteFaceRequest &request)const;
void deleteFaceAsync(const Model::DeleteFaceRequest& request, const DeleteFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteFaceOutcomeCallable deleteFaceCallable(const Model::DeleteFaceRequest& request) const;
DeleteFaceDbOutcome deleteFaceDb(const Model::DeleteFaceDbRequest &request)const;
void deleteFaceDbAsync(const Model::DeleteFaceDbRequest& request, const DeleteFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteFaceDbOutcomeCallable deleteFaceDbCallable(const Model::DeleteFaceDbRequest& request) const;
DeleteFaceEntityOutcome deleteFaceEntity(const Model::DeleteFaceEntityRequest &request)const;
void deleteFaceEntityAsync(const Model::DeleteFaceEntityRequest& request, const DeleteFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteFaceEntityOutcomeCallable deleteFaceEntityCallable(const Model::DeleteFaceEntityRequest& request) const;
DetectBodyCountOutcome detectBodyCount(const Model::DetectBodyCountRequest &request)const;
void detectBodyCountAsync(const Model::DetectBodyCountRequest& request, const DetectBodyCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectBodyCountOutcomeCallable detectBodyCountCallable(const Model::DetectBodyCountRequest& request) const;
DetectCelebrityOutcome detectCelebrity(const Model::DetectCelebrityRequest &request)const;
void detectCelebrityAsync(const Model::DetectCelebrityRequest& request, const DetectCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectCelebrityOutcomeCallable detectCelebrityCallable(const Model::DetectCelebrityRequest& request) const;
DetectChefCapOutcome detectChefCap(const Model::DetectChefCapRequest &request)const;
void detectChefCapAsync(const Model::DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectChefCapOutcomeCallable detectChefCapCallable(const Model::DetectChefCapRequest& request) const;
DetectFaceOutcome detectFace(const Model::DetectFaceRequest &request)const;
void detectFaceAsync(const Model::DetectFaceRequest& request, const DetectFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectFaceOutcomeCallable detectFaceCallable(const Model::DetectFaceRequest& request) const;
DetectIPCPedestrianOutcome detectIPCPedestrian(const Model::DetectIPCPedestrianRequest &request)const;
void detectIPCPedestrianAsync(const Model::DetectIPCPedestrianRequest& request, const DetectIPCPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectIPCPedestrianOutcomeCallable detectIPCPedestrianCallable(const Model::DetectIPCPedestrianRequest& request) const;
DetectLivingFaceOutcome detectLivingFace(const Model::DetectLivingFaceRequest &request)const;
void detectLivingFaceAsync(const Model::DetectLivingFaceRequest& request, const DetectLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectLivingFaceOutcomeCallable detectLivingFaceCallable(const Model::DetectLivingFaceRequest& request) const;
DetectMaskOutcome detectMask(const Model::DetectMaskRequest &request)const;
void detectMaskAsync(const Model::DetectMaskRequest& request, const DetectMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectMaskOutcomeCallable detectMaskCallable(const Model::DetectMaskRequest& request) const;
DetectPedestrianOutcome detectPedestrian(const Model::DetectPedestrianRequest &request)const;
void detectPedestrianAsync(const Model::DetectPedestrianRequest& request, const DetectPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectPedestrianOutcomeCallable detectPedestrianCallable(const Model::DetectPedestrianRequest& request) const;
DetectVideoLivingFaceOutcome detectVideoLivingFace(const Model::DetectVideoLivingFaceRequest &request)const;
void detectVideoLivingFaceAsync(const Model::DetectVideoLivingFaceRequest& request, const DetectVideoLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectVideoLivingFaceOutcomeCallable detectVideoLivingFaceCallable(const Model::DetectVideoLivingFaceRequest& request) const;
EnhanceFaceOutcome enhanceFace(const Model::EnhanceFaceRequest &request)const;
void enhanceFaceAsync(const Model::EnhanceFaceRequest& request, const EnhanceFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnhanceFaceOutcomeCallable enhanceFaceCallable(const Model::EnhanceFaceRequest& request) const;
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;
FaceFilterOutcome faceFilter(const Model::FaceFilterRequest &request)const;
void faceFilterAsync(const Model::FaceFilterRequest& request, const FaceFilterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FaceFilterOutcomeCallable faceFilterCallable(const Model::FaceFilterRequest& request) const;
FaceMakeupOutcome faceMakeup(const Model::FaceMakeupRequest &request)const;
void faceMakeupAsync(const Model::FaceMakeupRequest& request, const FaceMakeupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FaceMakeupOutcomeCallable faceMakeupCallable(const Model::FaceMakeupRequest& request) const;
FaceTidyupOutcome faceTidyup(const Model::FaceTidyupRequest &request)const;
void faceTidyupAsync(const Model::FaceTidyupRequest& request, const FaceTidyupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FaceTidyupOutcomeCallable faceTidyupCallable(const Model::FaceTidyupRequest& request) const;
GenerateHumanAnimeStyleOutcome generateHumanAnimeStyle(const Model::GenerateHumanAnimeStyleRequest &request)const;
void generateHumanAnimeStyleAsync(const Model::GenerateHumanAnimeStyleRequest& request, const GenerateHumanAnimeStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateHumanAnimeStyleOutcomeCallable generateHumanAnimeStyleCallable(const Model::GenerateHumanAnimeStyleRequest& request) const;
GetFaceEntityOutcome getFaceEntity(const Model::GetFaceEntityRequest &request)const;
void getFaceEntityAsync(const Model::GetFaceEntityRequest& request, const GetFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetFaceEntityOutcomeCallable getFaceEntityCallable(const Model::GetFaceEntityRequest& request) const;
HandPostureOutcome handPosture(const Model::HandPostureRequest &request)const;
void handPostureAsync(const Model::HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HandPostureOutcomeCallable handPostureCallable(const Model::HandPostureRequest& request) const;
ListFaceDbsOutcome listFaceDbs(const Model::ListFaceDbsRequest &request)const;
void listFaceDbsAsync(const Model::ListFaceDbsRequest& request, const ListFaceDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFaceDbsOutcomeCallable listFaceDbsCallable(const Model::ListFaceDbsRequest& request) const;
ListFaceEntitiesOutcome listFaceEntities(const Model::ListFaceEntitiesRequest &request)const;
void listFaceEntitiesAsync(const Model::ListFaceEntitiesRequest& request, const ListFaceEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFaceEntitiesOutcomeCallable listFaceEntitiesCallable(const Model::ListFaceEntitiesRequest& request) const;
PedestrianDetectAttributeOutcome pedestrianDetectAttribute(const Model::PedestrianDetectAttributeRequest &request)const;
void pedestrianDetectAttributeAsync(const Model::PedestrianDetectAttributeRequest& request, const PedestrianDetectAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PedestrianDetectAttributeOutcomeCallable pedestrianDetectAttributeCallable(const Model::PedestrianDetectAttributeRequest& request) const;
RecognizeActionOutcome recognizeAction(const Model::RecognizeActionRequest &request)const;
void recognizeActionAsync(const Model::RecognizeActionRequest& request, const RecognizeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeActionOutcomeCallable recognizeActionCallable(const Model::RecognizeActionRequest& request) const;
RecognizeExpressionOutcome recognizeExpression(const Model::RecognizeExpressionRequest &request)const;
void recognizeExpressionAsync(const Model::RecognizeExpressionRequest& request, const RecognizeExpressionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeExpressionOutcomeCallable recognizeExpressionCallable(const Model::RecognizeExpressionRequest& request) const;
RecognizeFaceOutcome recognizeFace(const Model::RecognizeFaceRequest &request)const;
void recognizeFaceAsync(const Model::RecognizeFaceRequest& request, const RecognizeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeFaceOutcomeCallable recognizeFaceCallable(const Model::RecognizeFaceRequest& request) const;
RecognizePublicFaceOutcome recognizePublicFace(const Model::RecognizePublicFaceRequest &request)const;
void recognizePublicFaceAsync(const Model::RecognizePublicFaceRequest& request, const RecognizePublicFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePublicFaceOutcomeCallable recognizePublicFaceCallable(const Model::RecognizePublicFaceRequest& request) const;
SearchFaceOutcome searchFace(const Model::SearchFaceRequest &request)const;
void searchFaceAsync(const Model::SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchFaceOutcomeCallable searchFaceCallable(const Model::SearchFaceRequest& request) const;
SwapFacialFeaturesOutcome swapFacialFeatures(const Model::SwapFacialFeaturesRequest &request)const;
void swapFacialFeaturesAsync(const Model::SwapFacialFeaturesRequest& request, const SwapFacialFeaturesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SwapFacialFeaturesOutcomeCallable swapFacialFeaturesCallable(const Model::SwapFacialFeaturesRequest& request) const;
UpdateFaceEntityOutcome updateFaceEntity(const Model::UpdateFaceEntityRequest &request)const;
void updateFaceEntityAsync(const Model::UpdateFaceEntityRequest& request, const UpdateFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateFaceEntityOutcomeCallable updateFaceEntityCallable(const Model::UpdateFaceEntityRequest& request) const;
VerifyFaceMaskOutcome verifyFaceMask(const Model::VerifyFaceMaskRequest &request)const;
void verifyFaceMaskAsync(const Model::VerifyFaceMaskRequest& request, const VerifyFaceMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VerifyFaceMaskOutcomeCallable verifyFaceMaskCallable(const Model::VerifyFaceMaskRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_FACEBODY_FACEBODYCLIENT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/FacebodyClient.h
|
C++
|
apache-2.0
| 35,081
|
/*
* 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_FACEBODYEXPORT_H_
#define ALIBABACLOUD_FACEBODY_FACEBODYEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_FACEBODY_LIBRARY)
# define ALIBABACLOUD_FACEBODY_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_FACEBODY_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_FACEBODY_EXPORT
#endif
#endif // !ALIBABACLOUD_FACEBODY_FACEBODYEXPORT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/FacebodyExport.h
|
C
|
apache-2.0
| 1,086
|
/*
* 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_ADDFACEENTITYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT AddFaceEntityRequest : public RpcServiceRequest
{
public:
AddFaceEntityRequest();
~AddFaceEntityRequest();
std::string getEntityId()const;
void setEntityId(const std::string& entityId);
std::string getLabels()const;
void setLabels(const std::string& labels);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string entityId_;
std::string labels_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/AddFaceEntityRequest.h
|
C++
|
apache-2.0
| 1,551
|
/*
* 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_ADDFACEENTITYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYRESULT_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 AddFaceEntityResult : public ServiceResult
{
public:
AddFaceEntityResult();
explicit AddFaceEntityResult(const std::string &payload);
~AddFaceEntityResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/AddFaceEntityResult.h
|
C++
|
apache-2.0
| 1,332
|
/*
* 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_ADDFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT AddFaceRequest : public RpcServiceRequest
{
public:
AddFaceRequest();
~AddFaceRequest();
std::string getEntityId()const;
void setEntityId(const std::string& entityId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
std::string getExtraData()const;
void setExtraData(const std::string& extraData);
private:
std::string entityId_;
std::string dbName_;
std::string imageUrl_;
std::string extraData_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/AddFaceRequest.h
|
C++
|
apache-2.0
| 1,644
|
/*
* 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_ADDFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACERESULT_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 AddFaceResult : public ServiceResult
{
public:
struct Data
{
std::string faceId;
};
AddFaceResult();
explicit AddFaceResult(const std::string &payload);
~AddFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/AddFaceResult.h
|
C++
|
apache-2.0
| 1,385
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_BLURFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_BLURFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT BlurFaceRequest : public RpcServiceRequest
{
public:
BlurFaceRequest();
~BlurFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_BLURFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/BlurFaceRequest.h
|
C++
|
apache-2.0
| 1,303
|
/*
* 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_BLURFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_BLURFACERESULT_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 BlurFaceResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
BlurFaceResult();
explicit BlurFaceResult(const std::string &payload);
~BlurFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_BLURFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/BlurFaceResult.h
|
C++
|
apache-2.0
| 1,394
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT BodyPostureRequest : public RpcServiceRequest
{
public:
BodyPostureRequest();
~BodyPostureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/BodyPostureRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* 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_BODYPOSTURERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTURERESULT_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 BodyPostureResult : public ServiceResult
{
public:
struct Data
{
struct MetaObject
{
int height;
int width;
};
struct Output
{
struct Result
{
struct Body
{
struct Position
{
std::vector<std::string> points;
};
float confident;
std::vector<Body::Position> positions;
std::string label;
};
std::vector<Result::Body> bodies;
};
std::vector<Output::Result> results;
int humanCount;
};
MetaObject metaObject;
std::vector<Output> outputs;
};
BodyPostureResult();
explicit BodyPostureResult(const std::string &payload);
~BodyPostureResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTURERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/BodyPostureResult.h
|
C++
|
apache-2.0
| 1,924
|
/*
* 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_COMPAREFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CompareFaceRequest : public RpcServiceRequest
{
public:
CompareFaceRequest();
~CompareFaceRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURLB()const;
void setImageURLB(const std::string& imageURLB);
std::string getImageURLA()const;
void setImageURLA(const std::string& imageURLA);
private:
int imageType_;
std::string imageURLB_;
std::string imageURLA_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CompareFaceRequest.h
|
C++
|
apache-2.0
| 1,536
|
/*
* 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_COMPAREFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACERESULT_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 CompareFaceResult : public ServiceResult
{
public:
struct Data
{
std::vector<double> thresholds;
float confidence;
std::vector<double> rectAList;
std::vector<double> rectBList;
};
CompareFaceResult();
explicit CompareFaceResult(const std::string &payload);
~CompareFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CompareFaceResult.h
|
C++
|
apache-2.0
| 1,520
|
/*
* 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_COUNTCROWDREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_COUNTCROWDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CountCrowdRequest : public RpcServiceRequest
{
public:
CountCrowdRequest();
~CountCrowdRequest();
bool getIsShow()const;
void setIsShow(bool isShow);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool isShow_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_COUNTCROWDREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CountCrowdRequest.h
|
C++
|
apache-2.0
| 1,396
|
/*
* 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_COUNTCROWDRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_COUNTCROWDRESULT_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 CountCrowdResult : public ServiceResult
{
public:
struct Data
{
int peopleNumber;
std::string hotMap;
};
CountCrowdResult();
explicit CountCrowdResult(const std::string &payload);
~CountCrowdResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_COUNTCROWDRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CountCrowdResult.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_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT CreateFaceDbRequest : public RpcServiceRequest
{
public:
CreateFaceDbRequest();
~CreateFaceDbRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CreateFaceDbRequest.h
|
C++
|
apache-2.0
| 1,311
|
/*
* 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_CREATEFACEDBRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBRESULT_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 CreateFaceDbResult : public ServiceResult
{
public:
CreateFaceDbResult();
explicit CreateFaceDbResult(const std::string &payload);
~CreateFaceDbResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/CreateFaceDbResult.h
|
C++
|
apache-2.0
| 1,325
|
/*
* 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_DELETEFACEDBREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceDbRequest : public RpcServiceRequest
{
public:
DeleteFaceDbRequest();
~DeleteFaceDbRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceDbRequest.h
|
C++
|
apache-2.0
| 1,311
|
/*
* 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_DELETEFACEDBRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBRESULT_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 DeleteFaceDbResult : public ServiceResult
{
public:
DeleteFaceDbResult();
explicit DeleteFaceDbResult(const std::string &payload);
~DeleteFaceDbResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceDbResult.h
|
C++
|
apache-2.0
| 1,325
|
/*
* 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_DELETEFACEENTITYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceEntityRequest : public RpcServiceRequest
{
public:
DeleteFaceEntityRequest();
~DeleteFaceEntityRequest();
std::string getEntityId()const;
void setEntityId(const std::string& entityId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string entityId_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceEntityRequest.h
|
C++
|
apache-2.0
| 1,460
|
/*
* 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_DELETEFACEENTITYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYRESULT_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 DeleteFaceEntityResult : public ServiceResult
{
public:
DeleteFaceEntityResult();
explicit DeleteFaceEntityResult(const std::string &payload);
~DeleteFaceEntityResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceEntityResult.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_FACEBODY_MODEL_DELETEFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceRequest : public RpcServiceRequest
{
public:
DeleteFaceRequest();
~DeleteFaceRequest();
std::string getFaceId()const;
void setFaceId(const std::string& faceId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string faceId_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceRequest.h
|
C++
|
apache-2.0
| 1,416
|
/*
* 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_DELETEFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACERESULT_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 DeleteFaceResult : public ServiceResult
{
public:
DeleteFaceResult();
explicit DeleteFaceResult(const std::string &payload);
~DeleteFaceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DeleteFaceResult.h
|
C++
|
apache-2.0
| 1,311
|
/*
* 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_DETECTBODYCOUNTREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectBodyCountRequest : public RpcServiceRequest
{
public:
DetectBodyCountRequest();
~DetectBodyCountRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectBodyCountRequest.h
|
C++
|
apache-2.0
| 1,345
|
/*
* 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_DETECTBODYCOUNTRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTRESULT_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 DetectBodyCountResult : public ServiceResult
{
public:
struct Data
{
int personNumber;
};
DetectBodyCountResult();
explicit DetectBodyCountResult(const std::string &payload);
~DetectBodyCountResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectBodyCountResult.h
|
C++
|
apache-2.0
| 1,439
|
/*
* 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_DETECTCELEBRITYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectCelebrityRequest : public RpcServiceRequest
{
public:
DetectCelebrityRequest();
~DetectCelebrityRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectCelebrityRequest.h
|
C++
|
apache-2.0
| 1,345
|
/*
* 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_DETECTCELEBRITYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYRESULT_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 DetectCelebrityResult : public ServiceResult
{
public:
struct Data
{
struct FaceRecognizeResult
{
std::vector<std::string> faceBoxes;
std::string name;
};
std::vector<FaceRecognizeResult> faceRecognizeResults;
int height;
int width;
};
DetectCelebrityResult();
explicit DetectCelebrityResult(const std::string &payload);
~DetectCelebrityResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectCelebrityResult.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectChefCapRequest : public RpcServiceRequest
{
public:
DetectChefCapRequest();
~DetectChefCapRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectChefCapRequest.h
|
C++
|
apache-2.0
| 1,333
|
/*
* 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_DETECTCHEFCAPRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPRESULT_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 DetectChefCapResult : public ServiceResult
{
public:
struct Data
{
struct ElementsItem
{
std::string category;
float confidence;
std::vector<std::string> box;
};
std::vector<ElementsItem> elements;
};
DetectChefCapResult();
explicit DetectChefCapResult(const std::string &payload);
~DetectChefCapResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectChefCapResult.h
|
C++
|
apache-2.0
| 1,571
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_DETECTFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectFaceRequest : public RpcServiceRequest
{
public:
DetectFaceRequest();
~DetectFaceRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectFaceRequest.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_DETECTFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTFACERESULT_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 DetectFaceResult : public ServiceResult
{
public:
struct Data
{
struct Qualities
{
std::vector<std::string> noiseList;
std::vector<std::string> scoreList;
std::vector<std::string> blurList;
std::vector<std::string> maskList;
std::vector<std::string> glassList;
std::vector<std::string> fnfList;
std::vector<std::string> poseList1;
std::vector<std::string> illuList;
};
std::vector<std::string> faceProbabilityList;
int landmarkCount;
std::vector<std::string> faceRectangles;
std::vector<std::string> landmarks;
Qualities qualities;
int faceCount;
std::vector<std::string> poseList;
std::vector<std::string> pupils;
};
DetectFaceResult();
explicit DetectFaceResult(const std::string &payload);
~DetectFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectFaceResult.h
|
C++
|
apache-2.0
| 2,035
|
/*
* 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_DETECTIPCPEDESTRIANREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectIPCPedestrianRequest : public RpcServiceRequest
{
public:
struct URLList
{
std::string dataId;
std::string imageURL;
};
public:
DetectIPCPedestrianRequest();
~DetectIPCPedestrianRequest();
std::string getImageData()const;
void setImageData(const std::string& imageData);
std::vector<URLList> getURLList()const;
void setURLList(const std::vector<URLList>& uRLList);
bool getContinueOnError()const;
void setContinueOnError(bool continueOnError);
int getWidth()const;
void setWidth(int width);
int getHeight()const;
void setHeight(int height);
private:
std::string imageData_;
std::vector<URLList> uRLList_;
bool continueOnError_;
int width_;
int height_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectIPCPedestrianRequest.h
|
C++
|
apache-2.0
| 1,883
|
/*
* 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_DETECTIPCPEDESTRIANRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANRESULT_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 DetectIPCPedestrianResult : public ServiceResult
{
public:
struct Data
{
struct ImageInfoListItem
{
struct Element
{
float score;
std::vector<std::string> boxes;
};
std::string dataId;
std::string errorCode;
std::vector<ImageInfoListItem::Element> elements;
std::string errorMessage;
};
std::vector<ImageInfoListItem> imageInfoList;
};
DetectIPCPedestrianResult();
explicit DetectIPCPedestrianResult(const std::string &payload);
~DetectIPCPedestrianResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectIPCPedestrianResult.h
|
C++
|
apache-2.0
| 1,780
|
/*
* 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_DETECTLIVINGFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTLIVINGFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectLivingFaceRequest : public RpcServiceRequest
{
public:
struct Tasks
{
std::string imageURL;
};
public:
DetectLivingFaceRequest();
~DetectLivingFaceRequest();
std::vector<Tasks> getTasks()const;
void setTasks(const std::vector<Tasks>& tasks);
private:
std::vector<Tasks> tasks_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTLIVINGFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectLivingFaceRequest.h
|
C++
|
apache-2.0
| 1,433
|
/*
* 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_DETECTLIVINGFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTLIVINGFACERESULT_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 DetectLivingFaceResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct Result
{
struct Frame
{
float rate;
std::string url;
};
std::vector<Result::Frame> frames;
std::string suggestion;
float rate;
std::string label;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
};
std::vector<Element> elements;
};
DetectLivingFaceResult();
explicit DetectLivingFaceResult(const std::string &payload);
~DetectLivingFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTLIVINGFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectLivingFaceResult.h
|
C++
|
apache-2.0
| 1,831
|
/*
* 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_DETECTMASKREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectMaskRequest : public RpcServiceRequest
{
public:
DetectMaskRequest();
~DetectMaskRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectMaskRequest.h
|
C++
|
apache-2.0
| 1,315
|
/*
* 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_DETECTMASKRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKRESULT_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 DetectMaskResult : public ServiceResult
{
public:
struct Data
{
int mask;
float faceProbability;
};
DetectMaskResult();
explicit DetectMaskResult(const std::string &payload);
~DetectMaskResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectMaskResult.h
|
C++
|
apache-2.0
| 1,424
|
/*
* 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_DETECTPEDESTRIANREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectPedestrianRequest : public RpcServiceRequest
{
public:
DetectPedestrianRequest();
~DetectPedestrianRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectPedestrianRequest.h
|
C++
|
apache-2.0
| 1,351
|
/*
* 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_DETECTPEDESTRIANRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANRESULT_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 DetectPedestrianResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string type;
std::vector<std::string> boxes;
};
int height;
std::vector<Element> elements;
int width;
};
DetectPedestrianResult();
explicit DetectPedestrianResult(const std::string &payload);
~DetectPedestrianResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectPedestrianResult.h
|
C++
|
apache-2.0
| 1,608
|
/*
* 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_DETECTVIDEOLIVINGFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT DetectVideoLivingFaceRequest : public RpcServiceRequest
{
public:
DetectVideoLivingFaceRequest();
~DetectVideoLivingFaceRequest();
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectVideoLivingFaceRequest.h
|
C++
|
apache-2.0
| 1,381
|
/*
* 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_DETECTVIDEOLIVINGFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACERESULT_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 DetectVideoLivingFaceResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float faceConfidence;
std::vector<std::string> rect;
float liveConfidence;
};
std::vector<Element> elements;
};
DetectVideoLivingFaceResult();
explicit DetectVideoLivingFaceResult(const std::string &payload);
~DetectVideoLivingFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/DetectVideoLivingFaceResult.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT EnhanceFaceRequest : public RpcServiceRequest
{
public:
EnhanceFaceRequest();
~EnhanceFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/EnhanceFaceRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* 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_ENHANCEFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACERESULT_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 EnhanceFaceResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
EnhanceFaceResult();
explicit EnhanceFaceResult(const std::string &payload);
~EnhanceFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/EnhanceFaceResult.h
|
C++
|
apache-2.0
| 1,415
|
/*
* 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_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttrRequest : public RpcServiceRequest
{
public:
ExtractPedestrianFeatureAttrRequest();
~ExtractPedestrianFeatureAttrRequest();
std::string getMode()const;
void setMode(const std::string& mode);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string mode_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h
|
C++
|
apache-2.0
| 1,524
|
/*
* 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_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_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 ExtractPedestrianFeatureAttrResult : public ServiceResult
{
public:
struct Data
{
std::string hair;
std::string upperType;
float upperTypeScore;
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;
std::string lowerType;
float ageScore;
float objTypeScore;
std::string age;
};
ExtractPedestrianFeatureAttrResult();
explicit ExtractPedestrianFeatureAttrResult(const std::string &payload);
~ExtractPedestrianFeatureAttrResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h
|
C++
|
apache-2.0
| 1,970
|
/*
* 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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttributeRequest : public RpcServiceRequest
{
public:
struct UrlList
{
std::string url;
};
public:
ExtractPedestrianFeatureAttributeRequest();
~ExtractPedestrianFeatureAttributeRequest();
std::vector<UrlList> getUrlList()const;
void setUrlList(const std::vector<UrlList>& urlList);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::vector<UrlList> urlList_;
std::string mode_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h
|
C++
|
apache-2.0
| 1,764
|
/*
* 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;
std::string upperType;
float upperTypeScore;
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;
std::string lowerType;
float ageScore;
float objTypeScore;
std::string age;
};
std::string hair;
std::string upperType;
float upperTypeScore;
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;
std::string lowerType;
float ageScore;
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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h
|
C++
|
apache-2.0
| 2,557
|
/*
* 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_FACEBEAUTYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEBEAUTYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT FaceBeautyRequest : public RpcServiceRequest
{
public:
FaceBeautyRequest();
~FaceBeautyRequest();
float getSharp()const;
void setSharp(float sharp);
float getWhite()const;
void setWhite(float white);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
float getSmooth()const;
void setSmooth(float smooth);
private:
float sharp_;
float white_;
std::string imageURL_;
float smooth_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEBEAUTYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceBeautyRequest.h
|
C++
|
apache-2.0
| 1,559
|
/*
* 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_FACEBEAUTYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEBEAUTYRESULT_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 FaceBeautyResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
FaceBeautyResult();
explicit FaceBeautyResult(const std::string &payload);
~FaceBeautyResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEBEAUTYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceBeautyResult.h
|
C++
|
apache-2.0
| 1,408
|
/*
* 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_FACEFILTERREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEFILTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT FaceFilterRequest : public RpcServiceRequest
{
public:
FaceFilterRequest();
~FaceFilterRequest();
float getStrength()const;
void setStrength(float strength);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
float strength_;
std::string resourceType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEFILTERREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceFilterRequest.h
|
C++
|
apache-2.0
| 1,540
|
/*
* 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_FACEFILTERRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEFILTERRESULT_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 FaceFilterResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
FaceFilterResult();
explicit FaceFilterResult(const std::string &payload);
~FaceFilterResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEFILTERRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceFilterResult.h
|
C++
|
apache-2.0
| 1,408
|
/*
* 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_FACEMAKEUPREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEMAKEUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT FaceMakeupRequest : public RpcServiceRequest
{
public:
FaceMakeupRequest();
~FaceMakeupRequest();
float getStrength()const;
void setStrength(float strength);
std::string getMakeupType()const;
void setMakeupType(const std::string& makeupType);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
float strength_;
std::string makeupType_;
std::string resourceType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEMAKEUPREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceMakeupRequest.h
|
C++
|
apache-2.0
| 1,665
|
/*
* 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_FACEMAKEUPRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACEMAKEUPRESULT_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 FaceMakeupResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
FaceMakeupResult();
explicit FaceMakeupResult(const std::string &payload);
~FaceMakeupResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACEMAKEUPRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceMakeupResult.h
|
C++
|
apache-2.0
| 1,408
|
/*
* 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_FACETIDYUPREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACETIDYUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT FaceTidyupRequest : public RpcServiceRequest
{
public:
FaceTidyupRequest();
~FaceTidyupRequest();
int getShapeType()const;
void setShapeType(int shapeType);
float getStrength()const;
void setStrength(float strength);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int shapeType_;
float strength_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACETIDYUPREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceTidyupRequest.h
|
C++
|
apache-2.0
| 1,497
|
/*
* 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_FACETIDYUPRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_FACETIDYUPRESULT_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 FaceTidyupResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
FaceTidyupResult();
explicit FaceTidyupResult(const std::string &payload);
~FaceTidyupResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_FACETIDYUPRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/FaceTidyupResult.h
|
C++
|
apache-2.0
| 1,408
|
/*
* 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_GENERATEHUMANANIMESTYLEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GENERATEHUMANANIMESTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GenerateHumanAnimeStyleRequest : public RpcServiceRequest
{
public:
GenerateHumanAnimeStyleRequest();
~GenerateHumanAnimeStyleRequest();
std::string getAlgoType()const;
void setAlgoType(const std::string& algoType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string algoType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GENERATEHUMANANIMESTYLEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/GenerateHumanAnimeStyleRequest.h
|
C++
|
apache-2.0
| 1,510
|
/*
* 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_GENERATEHUMANANIMESTYLERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GENERATEHUMANANIMESTYLERESULT_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 GenerateHumanAnimeStyleResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
GenerateHumanAnimeStyleResult();
explicit GenerateHumanAnimeStyleResult(const std::string &payload);
~GenerateHumanAnimeStyleResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GENERATEHUMANANIMESTYLERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/GenerateHumanAnimeStyleResult.h
|
C++
|
apache-2.0
| 1,499
|
/*
* 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_GETFACEENTITYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT GetFaceEntityRequest : public RpcServiceRequest
{
public:
GetFaceEntityRequest();
~GetFaceEntityRequest();
std::string getEntityId()const;
void setEntityId(const std::string& entityId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string entityId_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/GetFaceEntityRequest.h
|
C++
|
apache-2.0
| 1,442
|
/*
* 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_GETFACEENTITYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYRESULT_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 GetFaceEntityResult : public ServiceResult
{
public:
struct Data
{
struct Face
{
std::string faceId;
};
std::string entityId;
std::string dbName;
std::string labels;
std::vector<Face> faces;
};
GetFaceEntityResult();
explicit GetFaceEntityResult(const std::string &payload);
~GetFaceEntityResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/GetFaceEntityResult.h
|
C++
|
apache-2.0
| 1,567
|
/*
* 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_HANDPOSTUREREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT HandPostureRequest : public RpcServiceRequest
{
public:
HandPostureRequest();
~HandPostureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTUREREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/HandPostureRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* 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_HANDPOSTURERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTURERESULT_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 HandPostureResult : public ServiceResult
{
public:
struct Data
{
struct MetaObject
{
int height;
int width;
};
struct Output
{
struct Result
{
struct Box
{
struct Position
{
std::vector<std::string> points;
};
float confident;
std::vector<Position> positions;
};
struct Hands
{
struct KeyPoint
{
struct Position2
{
std::vector<std::string> points3;
};
std::vector<KeyPoint::Position2> positions1;
std::string label;
};
float confident;
std::vector<KeyPoint> keyPoints;
};
Hands hands;
Box box;
};
std::vector<Output::Result> results;
int handCount;
};
MetaObject metaObject;
std::vector<Output> outputs;
};
HandPostureResult();
explicit HandPostureResult(const std::string &payload);
~HandPostureResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTURERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/HandPostureResult.h
|
C++
|
apache-2.0
| 2,209
|
/*
* 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_LISTFACEDBSREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListFaceDbsRequest : public RpcServiceRequest
{
public:
ListFaceDbsRequest();
~ListFaceDbsRequest();
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ListFaceDbsRequest.h
|
C++
|
apache-2.0
| 1,204
|
/*
* 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_LISTFACEDBSRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSRESULT_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 ListFaceDbsResult : public ServiceResult
{
public:
struct Data
{
struct DbListItem
{
std::string name;
};
std::vector<DbListItem> dbList;
};
ListFaceDbsResult();
explicit ListFaceDbsResult(const std::string &payload);
~ListFaceDbsResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ListFaceDbsResult.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT ListFaceEntitiesRequest : public RpcServiceRequest
{
public:
ListFaceEntitiesRequest();
~ListFaceEntitiesRequest();
std::string getEntityIdPrefix()const;
void setEntityIdPrefix(const std::string& entityIdPrefix);
int getLimit()const;
void setLimit(int limit);
std::string getOrder()const;
void setOrder(const std::string& order);
int getOffset()const;
void setOffset(int offset);
std::string getToken()const;
void setToken(const std::string& token);
std::string getLabels()const;
void setLabels(const std::string& labels);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string entityIdPrefix_;
int limit_;
std::string order_;
int offset_;
std::string token_;
std::string labels_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ListFaceEntitiesRequest.h
|
C++
|
apache-2.0
| 1,955
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_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 ListFaceEntitiesResult : public ServiceResult
{
public:
struct Data
{
struct Entity
{
std::string entityId;
long createdAt;
std::string dbName;
std::string labels;
int faceCount;
long updatedAt;
};
int totalCount;
std::string token;
std::vector<Entity> entities;
};
ListFaceEntitiesResult();
explicit ListFaceEntitiesResult(const std::string &payload);
~ListFaceEntitiesResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/ListFaceEntitiesResult.h
|
C++
|
apache-2.0
| 1,682
|
/*
* 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_PEDESTRIANDETECTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_PEDESTRIANDETECTATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT PedestrianDetectAttributeRequest : public RpcServiceRequest
{
public:
PedestrianDetectAttributeRequest();
~PedestrianDetectAttributeRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_PEDESTRIANDETECTATTRIBUTEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/PedestrianDetectAttributeRequest.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_PEDESTRIANDETECTATTRIBUTERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_PEDESTRIANDETECTATTRIBUTERESULT_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 PedestrianDetectAttributeResult : public ServiceResult
{
public:
struct Data
{
struct AttributesItem
{
struct Age
{
float score;
std::string name;
};
struct Backpack
{
float score;
std::string name;
};
struct Gender
{
float score;
std::string name;
};
struct Glasses
{
float score;
std::string name;
};
struct Handbag
{
float score;
std::string name;
};
struct Hat
{
float score;
std::string name;
};
struct LowerColor
{
float score;
std::string name;
};
struct LowerWear
{
float score;
std::string name;
};
struct Orient
{
float score;
std::string name;
};
struct ShoulderBag
{
float score;
std::string name;
};
struct UpperColor
{
float score;
std::string name;
};
struct UpperWear
{
float score;
std::string name;
};
Backpack backpack;
LowerWear lowerWear;
Orient orient;
ShoulderBag shoulderBag;
LowerColor lowerColor;
Glasses glasses;
UpperColor upperColor;
Handbag handbag;
Hat hat;
Gender gender;
Age age;
UpperWear upperWear;
};
struct BoxesItem
{
float score;
float bottomRightY;
float bottomRightX;
float topLeftY;
float topLeftX;
};
int personNumber;
std::vector<AttributesItem> attributes;
std::vector<BoxesItem> boxes;
};
PedestrianDetectAttributeResult();
explicit PedestrianDetectAttributeResult(const std::string &payload);
~PedestrianDetectAttributeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_PEDESTRIANDETECTATTRIBUTERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/PedestrianDetectAttributeResult.h
|
C++
|
apache-2.0
| 3,070
|
/*
* 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_RECOGNIZEACTIONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT RecognizeActionRequest : public RpcServiceRequest
{
public:
struct URLList
{
std::string uRL;
};
public:
RecognizeActionRequest();
~RecognizeActionRequest();
std::vector<URLList> getURLList()const;
void setURLList(const std::vector<URLList>& uRLList);
int getType()const;
void setType(int type);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
std::vector<URLList> uRLList_;
int type_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeActionRequest.h
|
C++
|
apache-2.0
| 1,625
|
/*
* 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_RECOGNIZEACTIONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONRESULT_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 RecognizeActionResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct BoxesItem
{
std::vector<std::string> box;
};
std::vector<std::string> scores;
std::vector<std::string> labels;
int timestamp;
std::vector<Element::BoxesItem> boxes;
};
std::vector<Element> elements;
};
RecognizeActionResult();
explicit RecognizeActionResult(const std::string &payload);
~RecognizeActionResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeActionResult.h
|
C++
|
apache-2.0
| 1,708
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT RecognizeExpressionRequest : public RpcServiceRequest
{
public:
RecognizeExpressionRequest();
~RecognizeExpressionRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeExpressionRequest.h
|
C++
|
apache-2.0
| 1,369
|
/*
* 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_RECOGNIZEEXPRESSIONRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONRESULT_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 RecognizeExpressionResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct FaceRectangle
{
int left;
int top;
int height;
int width;
};
std::string expression;
FaceRectangle faceRectangle;
float faceProbability;
};
std::vector<Element> elements;
};
RecognizeExpressionResult();
explicit RecognizeExpressionResult(const std::string &payload);
~RecognizeExpressionResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeExpressionResult.h
|
C++
|
apache-2.0
| 1,723
|
/*
* 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_RECOGNIZEFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT RecognizeFaceRequest : public RpcServiceRequest
{
public:
RecognizeFaceRequest();
~RecognizeFaceRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeFaceRequest.h
|
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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACERESULT_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 RecognizeFaceResult : public ServiceResult
{
public:
struct Data
{
struct Qualities
{
std::vector<std::string> noiseList;
std::vector<std::string> scoreList;
std::vector<std::string> blurList;
std::vector<std::string> maskList;
std::vector<std::string> glassList;
std::vector<std::string> fnfList;
std::vector<std::string> poseList1;
std::vector<std::string> illuList;
};
std::vector<std::string> beuatyList;
std::vector<std::string> faceRectangles;
Qualities qualities;
int denseFeatureLength;
std::vector<std::string> poseList;
std::vector<std::string> genderList;
std::vector<std::string> pupils;
std::vector<std::string> denseFeatures;
std::vector<std::string> faceProbabilityList;
std::vector<std::string> hatList;
int landmarkCount;
std::vector<std::string> ageList;
std::vector<std::string> glasses;
std::vector<std::string> landmarks;
std::vector<std::string> expressions;
int faceCount;
};
RecognizeFaceResult();
explicit RecognizeFaceResult(const std::string &payload);
~RecognizeFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizeFaceResult.h
|
C++
|
apache-2.0
| 2,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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT RecognizePublicFaceRequest : public RpcServiceRequest
{
public:
struct Task
{
std::string imageURL;
};
public:
RecognizePublicFaceRequest();
~RecognizePublicFaceRequest();
std::vector<Task> getTask()const;
void setTask(const std::vector<Task>& task);
private:
std::vector<Task> task_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizePublicFaceRequest.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_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_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 RecognizePublicFaceResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct Result
{
struct SubResult
{
struct Face
{
float rate;
std::string id;
std::string name;
};
float w;
float h;
float x;
float y;
std::vector<SubResult::Face> faces;
};
std::string suggestion;
float rate;
std::string label;
std::vector<Result::SubResult> subResults;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
};
std::vector<Element> elements;
};
RecognizePublicFaceResult();
explicit RecognizePublicFaceResult(const std::string &payload);
~RecognizePublicFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/RecognizePublicFaceResult.h
|
C++
|
apache-2.0
| 2,045
|
/*
* 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_SEARCHFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT SearchFaceRequest : public RpcServiceRequest
{
public:
SearchFaceRequest();
~SearchFaceRequest();
std::string getDbNames()const;
void setDbNames(const std::string& dbNames);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
int getLimit()const;
void setLimit(int limit);
private:
std::string dbNames_;
std::string dbName_;
std::string imageUrl_;
int limit_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/SearchFaceRequest.h
|
C++
|
apache-2.0
| 1,611
|
/*
* 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_SEARCHFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACERESULT_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 SearchFaceResult : public ServiceResult
{
public:
struct Data
{
struct MatchListItem
{
struct Location
{
int x;
int y;
int height;
int width;
};
struct FaceItemsItem
{
std::string faceId;
std::string entityId;
float score;
std::string dbName;
std::string extraData;
};
std::vector<MatchListItem::FaceItemsItem> faceItems;
Location location;
};
std::vector<MatchListItem> matchList;
};
SearchFaceResult();
explicit SearchFaceResult(const std::string &payload);
~SearchFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/SearchFaceResult.h
|
C++
|
apache-2.0
| 1,830
|
/*
* 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_SWAPFACIALFEATURESREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT SwapFacialFeaturesRequest : public RpcServiceRequest
{
public:
SwapFacialFeaturesRequest();
~SwapFacialFeaturesRequest();
std::string getTargetImageURL()const;
void setTargetImageURL(const std::string& targetImageURL);
std::string getSourceImageURL()const;
void setSourceImageURL(const std::string& sourceImageURL);
std::string getEditPart()const;
void setEditPart(const std::string& editPart);
private:
std::string targetImageURL_;
std::string sourceImageURL_;
std::string editPart_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/SwapFacialFeaturesRequest.h
|
C++
|
apache-2.0
| 1,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.
*/
#ifndef ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESRESULT_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 SwapFacialFeaturesResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
SwapFacialFeaturesResult();
explicit SwapFacialFeaturesResult(const std::string &payload);
~SwapFacialFeaturesResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/SwapFacialFeaturesResult.h
|
C++
|
apache-2.0
| 1,464
|
/*
* 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_UPDATEFACEENTITYREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT UpdateFaceEntityRequest : public RpcServiceRequest
{
public:
UpdateFaceEntityRequest();
~UpdateFaceEntityRequest();
std::string getEntityId()const;
void setEntityId(const std::string& entityId);
std::string getLabels()const;
void setLabels(const std::string& labels);
std::string getDbName()const;
void setDbName(const std::string& dbName);
private:
std::string entityId_;
std::string labels_;
std::string dbName_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/UpdateFaceEntityRequest.h
|
C++
|
apache-2.0
| 1,569
|
/*
* 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_UPDATEFACEENTITYRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYRESULT_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 UpdateFaceEntityResult : public ServiceResult
{
public:
UpdateFaceEntityResult();
explicit UpdateFaceEntityResult(const std::string &payload);
~UpdateFaceEntityResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/UpdateFaceEntityResult.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_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/facebody/FacebodyExport.h>
namespace AlibabaCloud
{
namespace Facebody
{
namespace Model
{
class ALIBABACLOUD_FACEBODY_EXPORT VerifyFaceMaskRequest : public RpcServiceRequest
{
public:
VerifyFaceMaskRequest();
~VerifyFaceMaskRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
std::string getRefUrl()const;
void setRefUrl(const std::string& refUrl);
private:
std::string imageURL_;
std::string refUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/VerifyFaceMaskRequest.h
|
C++
|
apache-2.0
| 1,448
|
/*
* 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_VERIFYFACEMASKRESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKRESULT_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 VerifyFaceMaskResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> thresholds;
float confidence;
int mask;
std::vector<std::string> rectangle;
std::vector<std::string> rectangleRef;
int maskRef;
};
VerifyFaceMaskResult();
explicit VerifyFaceMaskResult(const std::string &payload);
~VerifyFaceMaskResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/include/alibabacloud/facebody/model/VerifyFaceMaskResult.h
|
C++
|
apache-2.0
| 1,592
|
/*
* 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/FacebodyClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
namespace
{
const std::string SERVICE_NAME = "facebody";
}
FacebodyClient::FacebodyClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "facebody");
}
FacebodyClient::FacebodyClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "facebody");
}
FacebodyClient::FacebodyClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "facebody");
}
FacebodyClient::~FacebodyClient()
{}
FacebodyClient::AddFaceOutcome FacebodyClient::addFace(const AddFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddFaceOutcome(AddFaceResult(outcome.result()));
else
return AddFaceOutcome(outcome.error());
}
void FacebodyClient::addFaceAsync(const AddFaceRequest& request, const AddFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::AddFaceOutcomeCallable FacebodyClient::addFaceCallable(const AddFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddFaceOutcome()>>(
[this, request]()
{
return this->addFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::AddFaceEntityOutcome FacebodyClient::addFaceEntity(const AddFaceEntityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddFaceEntityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddFaceEntityOutcome(AddFaceEntityResult(outcome.result()));
else
return AddFaceEntityOutcome(outcome.error());
}
void FacebodyClient::addFaceEntityAsync(const AddFaceEntityRequest& request, const AddFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addFaceEntity(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::AddFaceEntityOutcomeCallable FacebodyClient::addFaceEntityCallable(const AddFaceEntityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddFaceEntityOutcome()>>(
[this, request]()
{
return this->addFaceEntity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::BlurFaceOutcome FacebodyClient::blurFace(const BlurFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BlurFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BlurFaceOutcome(BlurFaceResult(outcome.result()));
else
return BlurFaceOutcome(outcome.error());
}
void FacebodyClient::blurFaceAsync(const BlurFaceRequest& request, const BlurFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, blurFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::BlurFaceOutcomeCallable FacebodyClient::blurFaceCallable(const BlurFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BlurFaceOutcome()>>(
[this, request]()
{
return this->blurFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::BodyPostureOutcome FacebodyClient::bodyPosture(const BodyPostureRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BodyPostureOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BodyPostureOutcome(BodyPostureResult(outcome.result()));
else
return BodyPostureOutcome(outcome.error());
}
void FacebodyClient::bodyPostureAsync(const BodyPostureRequest& request, const BodyPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, bodyPosture(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::BodyPostureOutcomeCallable FacebodyClient::bodyPostureCallable(const BodyPostureRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BodyPostureOutcome()>>(
[this, request]()
{
return this->bodyPosture(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::CompareFaceOutcome FacebodyClient::compareFace(const CompareFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CompareFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CompareFaceOutcome(CompareFaceResult(outcome.result()));
else
return CompareFaceOutcome(outcome.error());
}
void FacebodyClient::compareFaceAsync(const CompareFaceRequest& request, const CompareFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, compareFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::CompareFaceOutcomeCallable FacebodyClient::compareFaceCallable(const CompareFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CompareFaceOutcome()>>(
[this, request]()
{
return this->compareFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::CountCrowdOutcome FacebodyClient::countCrowd(const CountCrowdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CountCrowdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CountCrowdOutcome(CountCrowdResult(outcome.result()));
else
return CountCrowdOutcome(outcome.error());
}
void FacebodyClient::countCrowdAsync(const CountCrowdRequest& request, const CountCrowdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, countCrowd(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::CountCrowdOutcomeCallable FacebodyClient::countCrowdCallable(const CountCrowdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CountCrowdOutcome()>>(
[this, request]()
{
return this->countCrowd(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::CreateFaceDbOutcome FacebodyClient::createFaceDb(const CreateFaceDbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateFaceDbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateFaceDbOutcome(CreateFaceDbResult(outcome.result()));
else
return CreateFaceDbOutcome(outcome.error());
}
void FacebodyClient::createFaceDbAsync(const CreateFaceDbRequest& request, const CreateFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createFaceDb(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::CreateFaceDbOutcomeCallable FacebodyClient::createFaceDbCallable(const CreateFaceDbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateFaceDbOutcome()>>(
[this, request]()
{
return this->createFaceDb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteFaceOutcome FacebodyClient::deleteFace(const DeleteFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteFaceOutcome(DeleteFaceResult(outcome.result()));
else
return DeleteFaceOutcome(outcome.error());
}
void FacebodyClient::deleteFaceAsync(const DeleteFaceRequest& request, const DeleteFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeleteFaceOutcomeCallable FacebodyClient::deleteFaceCallable(const DeleteFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteFaceOutcome()>>(
[this, request]()
{
return this->deleteFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteFaceDbOutcome FacebodyClient::deleteFaceDb(const DeleteFaceDbRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteFaceDbOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteFaceDbOutcome(DeleteFaceDbResult(outcome.result()));
else
return DeleteFaceDbOutcome(outcome.error());
}
void FacebodyClient::deleteFaceDbAsync(const DeleteFaceDbRequest& request, const DeleteFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteFaceDb(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeleteFaceDbOutcomeCallable FacebodyClient::deleteFaceDbCallable(const DeleteFaceDbRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteFaceDbOutcome()>>(
[this, request]()
{
return this->deleteFaceDb(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteFaceEntityOutcome FacebodyClient::deleteFaceEntity(const DeleteFaceEntityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteFaceEntityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteFaceEntityOutcome(DeleteFaceEntityResult(outcome.result()));
else
return DeleteFaceEntityOutcome(outcome.error());
}
void FacebodyClient::deleteFaceEntityAsync(const DeleteFaceEntityRequest& request, const DeleteFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteFaceEntity(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeleteFaceEntityOutcomeCallable FacebodyClient::deleteFaceEntityCallable(const DeleteFaceEntityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteFaceEntityOutcome()>>(
[this, request]()
{
return this->deleteFaceEntity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectBodyCountOutcome FacebodyClient::detectBodyCount(const DetectBodyCountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectBodyCountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectBodyCountOutcome(DetectBodyCountResult(outcome.result()));
else
return DetectBodyCountOutcome(outcome.error());
}
void FacebodyClient::detectBodyCountAsync(const DetectBodyCountRequest& request, const DetectBodyCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectBodyCount(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectBodyCountOutcomeCallable FacebodyClient::detectBodyCountCallable(const DetectBodyCountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectBodyCountOutcome()>>(
[this, request]()
{
return this->detectBodyCount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectCelebrityOutcome FacebodyClient::detectCelebrity(const DetectCelebrityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectCelebrityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectCelebrityOutcome(DetectCelebrityResult(outcome.result()));
else
return DetectCelebrityOutcome(outcome.error());
}
void FacebodyClient::detectCelebrityAsync(const DetectCelebrityRequest& request, const DetectCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectCelebrity(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectCelebrityOutcomeCallable FacebodyClient::detectCelebrityCallable(const DetectCelebrityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectCelebrityOutcome()>>(
[this, request]()
{
return this->detectCelebrity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectChefCapOutcome FacebodyClient::detectChefCap(const DetectChefCapRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectChefCapOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectChefCapOutcome(DetectChefCapResult(outcome.result()));
else
return DetectChefCapOutcome(outcome.error());
}
void FacebodyClient::detectChefCapAsync(const DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectChefCap(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectChefCapOutcomeCallable FacebodyClient::detectChefCapCallable(const DetectChefCapRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectChefCapOutcome()>>(
[this, request]()
{
return this->detectChefCap(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectFaceOutcome FacebodyClient::detectFace(const DetectFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectFaceOutcome(DetectFaceResult(outcome.result()));
else
return DetectFaceOutcome(outcome.error());
}
void FacebodyClient::detectFaceAsync(const DetectFaceRequest& request, const DetectFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectFaceOutcomeCallable FacebodyClient::detectFaceCallable(const DetectFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectFaceOutcome()>>(
[this, request]()
{
return this->detectFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectIPCPedestrianOutcome FacebodyClient::detectIPCPedestrian(const DetectIPCPedestrianRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectIPCPedestrianOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectIPCPedestrianOutcome(DetectIPCPedestrianResult(outcome.result()));
else
return DetectIPCPedestrianOutcome(outcome.error());
}
void FacebodyClient::detectIPCPedestrianAsync(const DetectIPCPedestrianRequest& request, const DetectIPCPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectIPCPedestrian(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectIPCPedestrianOutcomeCallable FacebodyClient::detectIPCPedestrianCallable(const DetectIPCPedestrianRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectIPCPedestrianOutcome()>>(
[this, request]()
{
return this->detectIPCPedestrian(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectLivingFaceOutcome FacebodyClient::detectLivingFace(const DetectLivingFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectLivingFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectLivingFaceOutcome(DetectLivingFaceResult(outcome.result()));
else
return DetectLivingFaceOutcome(outcome.error());
}
void FacebodyClient::detectLivingFaceAsync(const DetectLivingFaceRequest& request, const DetectLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectLivingFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectLivingFaceOutcomeCallable FacebodyClient::detectLivingFaceCallable(const DetectLivingFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectLivingFaceOutcome()>>(
[this, request]()
{
return this->detectLivingFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectMaskOutcome FacebodyClient::detectMask(const DetectMaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectMaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectMaskOutcome(DetectMaskResult(outcome.result()));
else
return DetectMaskOutcome(outcome.error());
}
void FacebodyClient::detectMaskAsync(const DetectMaskRequest& request, const DetectMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectMask(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectMaskOutcomeCallable FacebodyClient::detectMaskCallable(const DetectMaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectMaskOutcome()>>(
[this, request]()
{
return this->detectMask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectPedestrianOutcome FacebodyClient::detectPedestrian(const DetectPedestrianRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectPedestrianOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectPedestrianOutcome(DetectPedestrianResult(outcome.result()));
else
return DetectPedestrianOutcome(outcome.error());
}
void FacebodyClient::detectPedestrianAsync(const DetectPedestrianRequest& request, const DetectPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectPedestrian(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectPedestrianOutcomeCallable FacebodyClient::detectPedestrianCallable(const DetectPedestrianRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectPedestrianOutcome()>>(
[this, request]()
{
return this->detectPedestrian(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DetectVideoLivingFaceOutcome FacebodyClient::detectVideoLivingFace(const DetectVideoLivingFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DetectVideoLivingFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DetectVideoLivingFaceOutcome(DetectVideoLivingFaceResult(outcome.result()));
else
return DetectVideoLivingFaceOutcome(outcome.error());
}
void FacebodyClient::detectVideoLivingFaceAsync(const DetectVideoLivingFaceRequest& request, const DetectVideoLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, detectVideoLivingFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DetectVideoLivingFaceOutcomeCallable FacebodyClient::detectVideoLivingFaceCallable(const DetectVideoLivingFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DetectVideoLivingFaceOutcome()>>(
[this, request]()
{
return this->detectVideoLivingFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::EnhanceFaceOutcome FacebodyClient::enhanceFace(const EnhanceFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnhanceFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnhanceFaceOutcome(EnhanceFaceResult(outcome.result()));
else
return EnhanceFaceOutcome(outcome.error());
}
void FacebodyClient::enhanceFaceAsync(const EnhanceFaceRequest& request, const EnhanceFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enhanceFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::EnhanceFaceOutcomeCallable FacebodyClient::enhanceFaceCallable(const EnhanceFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnhanceFaceOutcome()>>(
[this, request]()
{
return this->enhanceFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::ExtractPedestrianFeatureAttrOutcome FacebodyClient::extractPedestrianFeatureAttr(const ExtractPedestrianFeatureAttrRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ExtractPedestrianFeatureAttrOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ExtractPedestrianFeatureAttrOutcome(ExtractPedestrianFeatureAttrResult(outcome.result()));
else
return ExtractPedestrianFeatureAttrOutcome(outcome.error());
}
void FacebodyClient::extractPedestrianFeatureAttrAsync(const ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, extractPedestrianFeatureAttr(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ExtractPedestrianFeatureAttrOutcomeCallable FacebodyClient::extractPedestrianFeatureAttrCallable(const ExtractPedestrianFeatureAttrRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ExtractPedestrianFeatureAttrOutcome()>>(
[this, request]()
{
return this->extractPedestrianFeatureAttr(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
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();
if (!endpointOutcome.isSuccess())
return FaceBeautyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FaceBeautyOutcome(FaceBeautyResult(outcome.result()));
else
return FaceBeautyOutcome(outcome.error());
}
void FacebodyClient::faceBeautyAsync(const FaceBeautyRequest& request, const FaceBeautyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, faceBeauty(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::FaceBeautyOutcomeCallable FacebodyClient::faceBeautyCallable(const FaceBeautyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FaceBeautyOutcome()>>(
[this, request]()
{
return this->faceBeauty(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::FaceFilterOutcome FacebodyClient::faceFilter(const FaceFilterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FaceFilterOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FaceFilterOutcome(FaceFilterResult(outcome.result()));
else
return FaceFilterOutcome(outcome.error());
}
void FacebodyClient::faceFilterAsync(const FaceFilterRequest& request, const FaceFilterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, faceFilter(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::FaceFilterOutcomeCallable FacebodyClient::faceFilterCallable(const FaceFilterRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FaceFilterOutcome()>>(
[this, request]()
{
return this->faceFilter(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::FaceMakeupOutcome FacebodyClient::faceMakeup(const FaceMakeupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FaceMakeupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FaceMakeupOutcome(FaceMakeupResult(outcome.result()));
else
return FaceMakeupOutcome(outcome.error());
}
void FacebodyClient::faceMakeupAsync(const FaceMakeupRequest& request, const FaceMakeupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, faceMakeup(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::FaceMakeupOutcomeCallable FacebodyClient::faceMakeupCallable(const FaceMakeupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FaceMakeupOutcome()>>(
[this, request]()
{
return this->faceMakeup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::FaceTidyupOutcome FacebodyClient::faceTidyup(const FaceTidyupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FaceTidyupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FaceTidyupOutcome(FaceTidyupResult(outcome.result()));
else
return FaceTidyupOutcome(outcome.error());
}
void FacebodyClient::faceTidyupAsync(const FaceTidyupRequest& request, const FaceTidyupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, faceTidyup(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::FaceTidyupOutcomeCallable FacebodyClient::faceTidyupCallable(const FaceTidyupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FaceTidyupOutcome()>>(
[this, request]()
{
return this->faceTidyup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::GenerateHumanAnimeStyleOutcome FacebodyClient::generateHumanAnimeStyle(const GenerateHumanAnimeStyleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateHumanAnimeStyleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateHumanAnimeStyleOutcome(GenerateHumanAnimeStyleResult(outcome.result()));
else
return GenerateHumanAnimeStyleOutcome(outcome.error());
}
void FacebodyClient::generateHumanAnimeStyleAsync(const GenerateHumanAnimeStyleRequest& request, const GenerateHumanAnimeStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateHumanAnimeStyle(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::GenerateHumanAnimeStyleOutcomeCallable FacebodyClient::generateHumanAnimeStyleCallable(const GenerateHumanAnimeStyleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateHumanAnimeStyleOutcome()>>(
[this, request]()
{
return this->generateHumanAnimeStyle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::GetFaceEntityOutcome FacebodyClient::getFaceEntity(const GetFaceEntityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetFaceEntityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetFaceEntityOutcome(GetFaceEntityResult(outcome.result()));
else
return GetFaceEntityOutcome(outcome.error());
}
void FacebodyClient::getFaceEntityAsync(const GetFaceEntityRequest& request, const GetFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getFaceEntity(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::GetFaceEntityOutcomeCallable FacebodyClient::getFaceEntityCallable(const GetFaceEntityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetFaceEntityOutcome()>>(
[this, request]()
{
return this->getFaceEntity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::HandPostureOutcome FacebodyClient::handPosture(const HandPostureRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HandPostureOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HandPostureOutcome(HandPostureResult(outcome.result()));
else
return HandPostureOutcome(outcome.error());
}
void FacebodyClient::handPostureAsync(const HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, handPosture(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::HandPostureOutcomeCallable FacebodyClient::handPostureCallable(const HandPostureRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HandPostureOutcome()>>(
[this, request]()
{
return this->handPosture(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::ListFaceDbsOutcome FacebodyClient::listFaceDbs(const ListFaceDbsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListFaceDbsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListFaceDbsOutcome(ListFaceDbsResult(outcome.result()));
else
return ListFaceDbsOutcome(outcome.error());
}
void FacebodyClient::listFaceDbsAsync(const ListFaceDbsRequest& request, const ListFaceDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listFaceDbs(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ListFaceDbsOutcomeCallable FacebodyClient::listFaceDbsCallable(const ListFaceDbsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListFaceDbsOutcome()>>(
[this, request]()
{
return this->listFaceDbs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::ListFaceEntitiesOutcome FacebodyClient::listFaceEntities(const ListFaceEntitiesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListFaceEntitiesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListFaceEntitiesOutcome(ListFaceEntitiesResult(outcome.result()));
else
return ListFaceEntitiesOutcome(outcome.error());
}
void FacebodyClient::listFaceEntitiesAsync(const ListFaceEntitiesRequest& request, const ListFaceEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listFaceEntities(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::ListFaceEntitiesOutcomeCallable FacebodyClient::listFaceEntitiesCallable(const ListFaceEntitiesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListFaceEntitiesOutcome()>>(
[this, request]()
{
return this->listFaceEntities(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::PedestrianDetectAttributeOutcome FacebodyClient::pedestrianDetectAttribute(const PedestrianDetectAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PedestrianDetectAttributeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PedestrianDetectAttributeOutcome(PedestrianDetectAttributeResult(outcome.result()));
else
return PedestrianDetectAttributeOutcome(outcome.error());
}
void FacebodyClient::pedestrianDetectAttributeAsync(const PedestrianDetectAttributeRequest& request, const PedestrianDetectAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pedestrianDetectAttribute(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::PedestrianDetectAttributeOutcomeCallable FacebodyClient::pedestrianDetectAttributeCallable(const PedestrianDetectAttributeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PedestrianDetectAttributeOutcome()>>(
[this, request]()
{
return this->pedestrianDetectAttribute(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::RecognizeActionOutcome FacebodyClient::recognizeAction(const RecognizeActionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeActionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeActionOutcome(RecognizeActionResult(outcome.result()));
else
return RecognizeActionOutcome(outcome.error());
}
void FacebodyClient::recognizeActionAsync(const RecognizeActionRequest& request, const RecognizeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeAction(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::RecognizeActionOutcomeCallable FacebodyClient::recognizeActionCallable(const RecognizeActionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeActionOutcome()>>(
[this, request]()
{
return this->recognizeAction(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::RecognizeExpressionOutcome FacebodyClient::recognizeExpression(const RecognizeExpressionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeExpressionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeExpressionOutcome(RecognizeExpressionResult(outcome.result()));
else
return RecognizeExpressionOutcome(outcome.error());
}
void FacebodyClient::recognizeExpressionAsync(const RecognizeExpressionRequest& request, const RecognizeExpressionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeExpression(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::RecognizeExpressionOutcomeCallable FacebodyClient::recognizeExpressionCallable(const RecognizeExpressionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeExpressionOutcome()>>(
[this, request]()
{
return this->recognizeExpression(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::RecognizeFaceOutcome FacebodyClient::recognizeFace(const RecognizeFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeFaceOutcome(RecognizeFaceResult(outcome.result()));
else
return RecognizeFaceOutcome(outcome.error());
}
void FacebodyClient::recognizeFaceAsync(const RecognizeFaceRequest& request, const RecognizeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::RecognizeFaceOutcomeCallable FacebodyClient::recognizeFaceCallable(const RecognizeFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeFaceOutcome()>>(
[this, request]()
{
return this->recognizeFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::RecognizePublicFaceOutcome FacebodyClient::recognizePublicFace(const RecognizePublicFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizePublicFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizePublicFaceOutcome(RecognizePublicFaceResult(outcome.result()));
else
return RecognizePublicFaceOutcome(outcome.error());
}
void FacebodyClient::recognizePublicFaceAsync(const RecognizePublicFaceRequest& request, const RecognizePublicFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizePublicFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::RecognizePublicFaceOutcomeCallable FacebodyClient::recognizePublicFaceCallable(const RecognizePublicFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizePublicFaceOutcome()>>(
[this, request]()
{
return this->recognizePublicFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::SearchFaceOutcome FacebodyClient::searchFace(const SearchFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchFaceOutcome(SearchFaceResult(outcome.result()));
else
return SearchFaceOutcome(outcome.error());
}
void FacebodyClient::searchFaceAsync(const SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::SearchFaceOutcomeCallable FacebodyClient::searchFaceCallable(const SearchFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchFaceOutcome()>>(
[this, request]()
{
return this->searchFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::SwapFacialFeaturesOutcome FacebodyClient::swapFacialFeatures(const SwapFacialFeaturesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SwapFacialFeaturesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SwapFacialFeaturesOutcome(SwapFacialFeaturesResult(outcome.result()));
else
return SwapFacialFeaturesOutcome(outcome.error());
}
void FacebodyClient::swapFacialFeaturesAsync(const SwapFacialFeaturesRequest& request, const SwapFacialFeaturesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, swapFacialFeatures(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::SwapFacialFeaturesOutcomeCallable FacebodyClient::swapFacialFeaturesCallable(const SwapFacialFeaturesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SwapFacialFeaturesOutcome()>>(
[this, request]()
{
return this->swapFacialFeatures(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::UpdateFaceEntityOutcome FacebodyClient::updateFaceEntity(const UpdateFaceEntityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateFaceEntityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateFaceEntityOutcome(UpdateFaceEntityResult(outcome.result()));
else
return UpdateFaceEntityOutcome(outcome.error());
}
void FacebodyClient::updateFaceEntityAsync(const UpdateFaceEntityRequest& request, const UpdateFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateFaceEntity(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::UpdateFaceEntityOutcomeCallable FacebodyClient::updateFaceEntityCallable(const UpdateFaceEntityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateFaceEntityOutcome()>>(
[this, request]()
{
return this->updateFaceEntity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::VerifyFaceMaskOutcome FacebodyClient::verifyFaceMask(const VerifyFaceMaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VerifyFaceMaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VerifyFaceMaskOutcome(VerifyFaceMaskResult(outcome.result()));
else
return VerifyFaceMaskOutcome(outcome.error());
}
void FacebodyClient::verifyFaceMaskAsync(const VerifyFaceMaskRequest& request, const VerifyFaceMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, verifyFaceMask(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::VerifyFaceMaskOutcomeCallable FacebodyClient::verifyFaceMaskCallable(const VerifyFaceMaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VerifyFaceMaskOutcome()>>(
[this, request]()
{
return this->verifyFaceMask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/FacebodyClient.cc
|
C++
|
apache-2.0
| 50,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/AddFaceEntityRequest.h>
using AlibabaCloud::Facebody::Model::AddFaceEntityRequest;
AddFaceEntityRequest::AddFaceEntityRequest() :
RpcServiceRequest("facebody", "2019-12-30", "AddFaceEntity")
{
setMethod(HttpRequest::Method::Post);
}
AddFaceEntityRequest::~AddFaceEntityRequest()
{}
std::string AddFaceEntityRequest::getEntityId()const
{
return entityId_;
}
void AddFaceEntityRequest::setEntityId(const std::string& entityId)
{
entityId_ = entityId;
setBodyParameter("EntityId", entityId);
}
std::string AddFaceEntityRequest::getLabels()const
{
return labels_;
}
void AddFaceEntityRequest::setLabels(const std::string& labels)
{
labels_ = labels;
setBodyParameter("Labels", labels);
}
std::string AddFaceEntityRequest::getDbName()const
{
return dbName_;
}
void AddFaceEntityRequest::setDbName(const std::string& dbName)
{
dbName_ = dbName;
setBodyParameter("DbName", dbName);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/facebody/src/model/AddFaceEntityRequest.cc
|
C++
|
apache-2.0
| 1,599
|
/*
* 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/AddFaceEntityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
AddFaceEntityResult::AddFaceEntityResult() :
ServiceResult()
{}
AddFaceEntityResult::AddFaceEntityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddFaceEntityResult::~AddFaceEntityResult()
{}
void AddFaceEntityResult::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/AddFaceEntityResult.cc
|
C++
|
apache-2.0
| 1,210
|