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

Release DeepfakeFace.

Browse Source
This commit is contained in:
sdk-team
2023-11-14 06:37:17 +00:00
parent 6cbb9bf950
commit d93b632d3b
8 changed files with 331 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1802
1.36.1803

4
facebody/CMakeLists.txt
View File

@@ -41,6 +41,8 @@ set(facebody_public_header_model
include/alibabacloud/facebody/model/CompareFaceWithMaskResult.h
include/alibabacloud/facebody/model/CreateFaceDbRequest.h
include/alibabacloud/facebody/model/CreateFaceDbResult.h
include/alibabacloud/facebody/model/DeepfakeFaceRequest.h
include/alibabacloud/facebody/model/DeepfakeFaceResult.h
include/alibabacloud/facebody/model/DeleteFaceRequest.h
include/alibabacloud/facebody/model/DeleteFaceResult.h
include/alibabacloud/facebody/model/DeleteFaceDbRequest.h
@@ -150,6 +152,8 @@ set(facebody_src
src/model/CompareFaceWithMaskResult.cc
src/model/CreateFaceDbRequest.cc
src/model/CreateFaceDbResult.cc
src/model/DeepfakeFaceRequest.cc
src/model/DeepfakeFaceResult.cc
src/model/DeleteFaceRequest.cc
src/model/DeleteFaceResult.cc
src/model/DeleteFaceDbRequest.cc

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

@@ -42,6 +42,8 @@
#include "model/CompareFaceWithMaskResult.h"
#include "model/CreateFaceDbRequest.h"
#include "model/CreateFaceDbResult.h"
#include "model/DeepfakeFaceRequest.h"
#include "model/DeepfakeFaceResult.h"
#include "model/DeleteFaceRequest.h"
#include "model/DeleteFaceResult.h"
#include "model/DeleteFaceDbRequest.h"
@@ -167,6 +169,9 @@ namespace AlibabaCloud
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::DeepfakeFaceResult> DeepfakeFaceOutcome;
typedef std::future<DeepfakeFaceOutcome> DeepfakeFaceOutcomeCallable;
typedef std::function<void(const FacebodyClient*, const Model::DeepfakeFaceRequest&, const DeepfakeFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeepfakeFaceAsyncHandler;
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;
@@ -331,6 +336,9 @@ namespace AlibabaCloud
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;
DeepfakeFaceOutcome deepfakeFace(const Model::DeepfakeFaceRequest &request)const;
void deepfakeFaceAsync(const Model::DeepfakeFaceRequest& request, const DeepfakeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeepfakeFaceOutcomeCallable deepfakeFaceCallable(const Model::DeepfakeFaceRequest& 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;

55
facebody/include/alibabacloud/facebody/model/DeepfakeFaceRequest.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_DEEPFAKEFACEREQUEST_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DEEPFAKEFACEREQUEST_H_
#include <alibabacloud/facebody/FacebodyExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Facebody {
namespace Model {
class ALIBABACLOUD_FACEBODY_EXPORT DeepfakeFaceRequest : public RpcServiceRequest {
public:
struct Tasks {
std::string imageURL;
std::string imageData;
};
DeepfakeFaceRequest();
~DeepfakeFaceRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::vector<Tasks> getTasks() const;
void setTasks(const std::vector<Tasks> &tasks);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
private:
bool formatResultToJson_;
std::string ossFile_;
std::vector<Tasks> tasks_;
std::string requestProxyBy_;
};
} // namespace Model
} // namespace Facebody
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DEEPFAKEFACEREQUEST_H_

76
facebody/include/alibabacloud/facebody/model/DeepfakeFaceResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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_DEEPFAKEFACERESULT_H_
#define ALIBABACLOUD_FACEBODY_MODEL_DEEPFAKEFACERESULT_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 DeepfakeFaceResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct Result
{
struct Rect
{
long left;
long top;
long height;
long width;
};
std::string messageTips;
Rect rect;
float confidence;
std::string label;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
long faceNumber;
};
std::vector<Element> elements;
};
DeepfakeFaceResult();
explicit DeepfakeFaceResult(const std::string &payload);
~DeepfakeFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_FACEBODY_MODEL_DEEPFAKEFACERESULT_H_

36
facebody/src/FacebodyClient.cc
View File

@@ -411,6 +411,42 @@ FacebodyClient::CreateFaceDbOutcomeCallable FacebodyClient::createFaceDbCallable
return task->get_future();
}
FacebodyClient::DeepfakeFaceOutcome FacebodyClient::deepfakeFace(const DeepfakeFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeepfakeFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeepfakeFaceOutcome(DeepfakeFaceResult(outcome.result()));
else
return DeepfakeFaceOutcome(outcome.error());
}
void FacebodyClient::deepfakeFaceAsync(const DeepfakeFaceRequest& request, const DeepfakeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deepfakeFace(request), context);
};
asyncExecute(new Runnable(fn));
}
FacebodyClient::DeepfakeFaceOutcomeCallable FacebodyClient::deepfakeFaceCallable(const DeepfakeFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeepfakeFaceOutcome()>>(
[this, request]()
{
return this->deepfakeFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FacebodyClient::DeleteFaceOutcome FacebodyClient::deleteFace(const DeleteFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

68
facebody/src/model/DeepfakeFaceRequest.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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/DeepfakeFaceRequest.h>
using AlibabaCloud::Facebody::Model::DeepfakeFaceRequest;
DeepfakeFaceRequest::DeepfakeFaceRequest()
: RpcServiceRequest("facebody", "2019-12-30", "DeepfakeFace") {
setMethod(HttpRequest::Method::Post);
}
DeepfakeFaceRequest::~DeepfakeFaceRequest() {}
bool DeepfakeFaceRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void DeepfakeFaceRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string DeepfakeFaceRequest::getOssFile() const {
return ossFile_;
}
void DeepfakeFaceRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::vector<DeepfakeFaceRequest::Tasks> DeepfakeFaceRequest::getTasks() const {
return tasks_;
}
void DeepfakeFaceRequest::setTasks(const std::vector<DeepfakeFaceRequest::Tasks> &tasks) {
tasks_ = tasks;
for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = std::string("Tasks") + "." + std::to_string(dep1 + 1);
setBodyParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
setBodyParameter(tasksObjStr + ".ImageData", tasksObj.imageData);
}
}
std::string DeepfakeFaceRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DeepfakeFaceRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}

83
facebody/src/model/DeepfakeFaceResult.cc Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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/DeepfakeFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Facebody;
using namespace AlibabaCloud::Facebody::Model;
DeepfakeFaceResult::DeepfakeFaceResult() :
ServiceResult()
{}
DeepfakeFaceResult::DeepfakeFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeepfakeFaceResult::~DeepfakeFaceResult()
{}
void DeepfakeFaceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["TaskId"].isNull())
elementObject.taskId = dataNodeElementsElement["TaskId"].asString();
if(!dataNodeElementsElement["FaceNumber"].isNull())
elementObject.faceNumber = std::stol(dataNodeElementsElement["FaceNumber"].asString());
auto allResultsNode = dataNodeElementsElement["Results"]["Result"];
for (auto dataNodeElementsElementResultsResult : allResultsNode)
{
Data::Element::Result resultsObject;
if(!dataNodeElementsElementResultsResult["Label"].isNull())
resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
if(!dataNodeElementsElementResultsResult["Confidence"].isNull())
resultsObject.confidence = std::stof(dataNodeElementsElementResultsResult["Confidence"].asString());
if(!dataNodeElementsElementResultsResult["MessageTips"].isNull())
resultsObject.messageTips = dataNodeElementsElementResultsResult["MessageTips"].asString();
auto rectNode = value["Rect"];
if(!rectNode["Left"].isNull())
resultsObject.rect.left = std::stol(rectNode["Left"].asString());
if(!rectNode["Top"].isNull())
resultsObject.rect.top = std::stol(rectNode["Top"].asString());
if(!rectNode["Width"].isNull())
resultsObject.rect.width = std::stol(rectNode["Width"].asString());
if(!rectNode["Height"].isNull())
resultsObject.rect.height = std::stol(rectNode["Height"].asString());
elementObject.results.push_back(resultsObject);
}
data_.elements.push_back(elementObject);
}
}
DeepfakeFaceResult::Data DeepfakeFaceResult::getData()const
{
return data_;
}