diff --git a/VERSION b/VERSION index 200d343aa..64ab3fa00 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1802 \ No newline at end of file +1.36.1803 \ No newline at end of file diff --git a/facebody/CMakeLists.txt b/facebody/CMakeLists.txt index 2907d93ac..9d168c6d3 100644 --- a/facebody/CMakeLists.txt +++ b/facebody/CMakeLists.txt @@ -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 diff --git a/facebody/include/alibabacloud/facebody/FacebodyClient.h b/facebody/include/alibabacloud/facebody/FacebodyClient.h index e5b9ef287..21d21ecab 100644 --- a/facebody/include/alibabacloud/facebody/FacebodyClient.h +++ b/facebody/include/alibabacloud/facebody/FacebodyClient.h @@ -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 CreateFaceDbOutcome; typedef std::future CreateFaceDbOutcomeCallable; typedef std::function&)> CreateFaceDbAsyncHandler; + typedef Outcome DeepfakeFaceOutcome; + typedef std::future DeepfakeFaceOutcomeCallable; + typedef std::function&)> DeepfakeFaceAsyncHandler; typedef Outcome DeleteFaceOutcome; typedef std::future DeleteFaceOutcomeCallable; typedef std::function&)> 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& 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& 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& context = nullptr) const; DeleteFaceOutcomeCallable deleteFaceCallable(const Model::DeleteFaceRequest& request) const; diff --git a/facebody/include/alibabacloud/facebody/model/DeepfakeFaceRequest.h b/facebody/include/alibabacloud/facebody/model/DeepfakeFaceRequest.h new file mode 100644 index 000000000..8b181ff71 --- /dev/null +++ b/facebody/include/alibabacloud/facebody/model/DeepfakeFaceRequest.h @@ -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 +#include +#include +#include +#include + +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 getTasks() const; + void setTasks(const std::vector &tasks); + std::string getRequestProxyBy() const; + void setRequestProxyBy(const std::string &requestProxyBy); + +private: + bool formatResultToJson_; + std::string ossFile_; + std::vector tasks_; + std::string requestProxyBy_; +}; +} // namespace Model +} // namespace Facebody +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_FACEBODY_MODEL_DEEPFAKEFACEREQUEST_H_ diff --git a/facebody/include/alibabacloud/facebody/model/DeepfakeFaceResult.h b/facebody/include/alibabacloud/facebody/model/DeepfakeFaceResult.h new file mode 100644 index 000000000..1ee484c4c --- /dev/null +++ b/facebody/include/alibabacloud/facebody/model/DeepfakeFaceResult.h @@ -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 +#include +#include +#include +#include + +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 results; + std::string imageURL; + long faceNumber; + }; + std::vector 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_ \ No newline at end of file diff --git a/facebody/src/FacebodyClient.cc b/facebody/src/FacebodyClient.cc index a4b5d4220..7c84f335e 100644 --- a/facebody/src/FacebodyClient.cc +++ b/facebody/src/FacebodyClient.cc @@ -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& 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>( + [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(); diff --git a/facebody/src/model/DeepfakeFaceRequest.cc b/facebody/src/model/DeepfakeFaceRequest.cc new file mode 100644 index 000000000..370e83c04 --- /dev/null +++ b/facebody/src/model/DeepfakeFaceRequest.cc @@ -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 + +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::getTasks() const { + return tasks_; +} + +void DeepfakeFaceRequest::setTasks(const std::vector &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); +} + diff --git a/facebody/src/model/DeepfakeFaceResult.cc b/facebody/src/model/DeepfakeFaceResult.cc new file mode 100644 index 000000000..cd194093a --- /dev/null +++ b/facebody/src/model/DeepfakeFaceResult.cc @@ -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 +#include + +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_; +} +