Release MonitorExamination.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-04-06 Version: 1.36.669
+- Release MonitorExamination.
+
 2021-04-06 Version: 1.36.668
 - Update ScreenChestCT DetectRibFracture.
 

VERSION

@@ -1 +1 @@
-1.36.668
+1.36.669

facebody/CMakeLists.txt

@@ -113,6 +113,8 @@ set(facebody_public_header_model
 	include/alibabacloud/facebody/model/ListFaceEntitiesResult.h
 	include/alibabacloud/facebody/model/MergeImageFaceRequest.h
 	include/alibabacloud/facebody/model/MergeImageFaceResult.h
+	include/alibabacloud/facebody/model/MonitorExaminationRequest.h
+	include/alibabacloud/facebody/model/MonitorExaminationResult.h
 	include/alibabacloud/facebody/model/PedestrianDetectAttributeRequest.h
 	include/alibabacloud/facebody/model/PedestrianDetectAttributeResult.h
 	include/alibabacloud/facebody/model/QueryFaceImageTemplateRequest.h
@@ -232,6 +234,8 @@ set(facebody_src
 	src/model/ListFaceEntitiesResult.cc
 	src/model/MergeImageFaceRequest.cc
 	src/model/MergeImageFaceResult.cc
+	src/model/MonitorExaminationRequest.cc
+	src/model/MonitorExaminationResult.cc
 	src/model/PedestrianDetectAttributeRequest.cc
 	src/model/PedestrianDetectAttributeResult.cc
 	src/model/QueryFaceImageTemplateRequest.cc

facebody/include/alibabacloud/facebody/FacebodyClient.h

@@ -114,6 +114,8 @@
 #include "model/ListFaceEntitiesResult.h"
 #include "model/MergeImageFaceRequest.h"
 #include "model/MergeImageFaceResult.h"
+#include "model/MonitorExaminationRequest.h"
+#include "model/MonitorExaminationResult.h"
 #include "model/PedestrianDetectAttributeRequest.h"
 #include "model/PedestrianDetectAttributeResult.h"
 #include "model/QueryFaceImageTemplateRequest.h"
@@ -285,6 +287,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::MergeImageFaceResult> MergeImageFaceOutcome;
 			typedef std::future<MergeImageFaceOutcome> MergeImageFaceOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::MergeImageFaceRequest&, const MergeImageFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MergeImageFaceAsyncHandler;
+			typedef Outcome<Error, Model::MonitorExaminationResult> MonitorExaminationOutcome;
+			typedef std::future<MonitorExaminationOutcome> MonitorExaminationOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::MonitorExaminationRequest&, const MonitorExaminationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MonitorExaminationAsyncHandler;
 			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;
@@ -464,6 +469,9 @@ namespace AlibabaCloud
 			MergeImageFaceOutcome mergeImageFace(const Model::MergeImageFaceRequest &request)const;
 			void mergeImageFaceAsync(const Model::MergeImageFaceRequest& request, const MergeImageFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			MergeImageFaceOutcomeCallable mergeImageFaceCallable(const Model::MergeImageFaceRequest& request) const;
+			MonitorExaminationOutcome monitorExamination(const Model::MonitorExaminationRequest &request)const;
+			void monitorExaminationAsync(const Model::MonitorExaminationRequest& request, const MonitorExaminationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MonitorExaminationOutcomeCallable monitorExaminationCallable(const Model::MonitorExaminationRequest& 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;

facebody/include/alibabacloud/facebody/model/DetectLivingFaceRequest.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 				struct Tasks
 				{
 					std::string imageURL;
+					std::string imageData;
 				};
 
 			public:

facebody/include/alibabacloud/facebody/model/MonitorExaminationRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_MONITOREXAMINATIONREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_MONITOREXAMINATIONREQUEST_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 MonitorExaminationRequest : public RpcServiceRequest
+			{
+
+			public:
+				MonitorExaminationRequest();
+				~MonitorExaminationRequest();
+
+				long getType()const;
+				void setType(long type);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				long type_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_MONITOREXAMINATIONREQUEST_H_

facebody/include/alibabacloud/facebody/model/MonitorExaminationResult.h

@@ -0,0 +1,90 @@
+/*
+ * 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_MONITOREXAMINATIONRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_MONITOREXAMINATIONRESULT_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 MonitorExaminationResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct PersonInfo
+					{
+						struct EarPhone
+						{
+							float score;
+							float threshold;
+						};
+						struct CellPhone
+						{
+							float score;
+							float threshold;
+						};
+						long personNumber;
+						EarPhone earPhone;
+						CellPhone cellPhone;
+					};
+					struct FaceInfo
+					{
+						struct Pose
+						{
+							float pitch;
+							float roll;
+							float yaw;
+						};
+						long completeness;
+						Pose pose;
+						long faceNumber;
+					};
+					PersonInfo personInfo;
+					float chatScore;
+					FaceInfo faceInfo;
+					float threshold;
+				};
+
+
+				MonitorExaminationResult();
+				explicit MonitorExaminationResult(const std::string &payload);
+				~MonitorExaminationResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_MONITOREXAMINATIONRESULT_H_

facebody/include/alibabacloud/facebody/model/RecognizePublicFaceRequest.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 				struct Task
 				{
 					std::string imageURL;
+					std::string imageData;
 				};
 
 			public:

facebody/include/alibabacloud/facebody/model/RecognizePublicFaceResult.h

@@ -47,8 +47,8 @@ namespace AlibabaCloud
 									std::string name;
 								};
 								float w;
-								float h;
 								float x;
+								float h;
 								float y;
 								std::vector<SubResult::Face> faces;
 							};

facebody/src/FacebodyClient.cc

@@ -1707,6 +1707,42 @@ FacebodyClient::MergeImageFaceOutcomeCallable FacebodyClient::mergeImageFaceCall
 	return task->get_future();
 }
 
+FacebodyClient::MonitorExaminationOutcome FacebodyClient::monitorExamination(const MonitorExaminationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MonitorExaminationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MonitorExaminationOutcome(MonitorExaminationResult(outcome.result()));
+	else
+		return MonitorExaminationOutcome(outcome.error());
+}
+
+void FacebodyClient::monitorExaminationAsync(const MonitorExaminationRequest& request, const MonitorExaminationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, monitorExamination(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::MonitorExaminationOutcomeCallable FacebodyClient::monitorExaminationCallable(const MonitorExaminationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MonitorExaminationOutcome()>>(
+			[this, request]()
+			{
+			return this->monitorExamination(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::PedestrianDetectAttributeOutcome FacebodyClient::pedestrianDetectAttribute(const PedestrianDetectAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

facebody/src/model/DetectLivingFaceRequest.cc

@@ -39,6 +39,7 @@ void DetectLivingFaceRequest::setTasks(const std::vector<Tasks>& tasks)
 		auto tasksObj = tasks.at(dep1);
 		std::string tasksObjStr = "Tasks." + std::to_string(dep1 + 1);
 		setParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
+		setParameter(tasksObjStr + ".ImageData", tasksObj.imageData);
 	}
 }
 

facebody/src/model/DetectLivingFaceResult.cc

@@ -52,12 +52,12 @@ void DetectLivingFaceResult::parse(const std::string &payload)
 		for (auto dataNodeElementsElementResultsResult : allResultsNode)
 		{
 			Data::Element::Result resultsObject;
-			if(!dataNodeElementsElementResultsResult["Label"].isNull())
-				resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
 			if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
 				resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
 			if(!dataNodeElementsElementResultsResult["Rate"].isNull())
 				resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
+			if(!dataNodeElementsElementResultsResult["Label"].isNull())
+				resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
 			auto allFramesNode = dataNodeElementsElementResultsResult["Frames"]["Frame"];
 			for (auto dataNodeElementsElementResultsResultFramesFrame : allFramesNode)
 			{

facebody/src/model/MonitorExaminationRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * 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/MonitorExaminationRequest.h>
+
+using AlibabaCloud::Facebody::Model::MonitorExaminationRequest;
+
+MonitorExaminationRequest::MonitorExaminationRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "MonitorExamination")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+MonitorExaminationRequest::~MonitorExaminationRequest()
+{}
+
+long MonitorExaminationRequest::getType()const
+{
+	return type_;
+}
+
+void MonitorExaminationRequest::setType(long type)
+{
+	type_ = type;
+	setBodyParameter("Type", std::to_string(type));
+}
+
+std::string MonitorExaminationRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void MonitorExaminationRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

facebody/src/model/MonitorExaminationResult.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/MonitorExaminationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Facebody;
+using namespace AlibabaCloud::Facebody::Model;
+
+MonitorExaminationResult::MonitorExaminationResult() :
+	ServiceResult()
+{}
+
+MonitorExaminationResult::MonitorExaminationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+MonitorExaminationResult::~MonitorExaminationResult()
+{}
+
+void MonitorExaminationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ChatScore"].isNull())
+		data_.chatScore = std::stof(dataNode["ChatScore"].asString());
+	if(!dataNode["Threshold"].isNull())
+		data_.threshold = std::stof(dataNode["Threshold"].asString());
+	auto personInfoNode = dataNode["PersonInfo"];
+	if(!personInfoNode["PersonNumber"].isNull())
+		data_.personInfo.personNumber = std::stol(personInfoNode["PersonNumber"].asString());
+	auto earPhoneNode = personInfoNode["EarPhone"];
+	if(!earPhoneNode["Score"].isNull())
+		data_.personInfo.earPhone.score = std::stof(earPhoneNode["Score"].asString());
+	if(!earPhoneNode["Threshold"].isNull())
+		data_.personInfo.earPhone.threshold = std::stof(earPhoneNode["Threshold"].asString());
+	auto cellPhoneNode = personInfoNode["CellPhone"];
+	if(!cellPhoneNode["Score"].isNull())
+		data_.personInfo.cellPhone.score = std::stof(cellPhoneNode["Score"].asString());
+	if(!cellPhoneNode["Threshold"].isNull())
+		data_.personInfo.cellPhone.threshold = std::stof(cellPhoneNode["Threshold"].asString());
+	auto faceInfoNode = dataNode["FaceInfo"];
+	if(!faceInfoNode["Completeness"].isNull())
+		data_.faceInfo.completeness = std::stol(faceInfoNode["Completeness"].asString());
+	if(!faceInfoNode["FaceNumber"].isNull())
+		data_.faceInfo.faceNumber = std::stol(faceInfoNode["FaceNumber"].asString());
+	auto poseNode = faceInfoNode["Pose"];
+	if(!poseNode["Pitch"].isNull())
+		data_.faceInfo.pose.pitch = std::stof(poseNode["Pitch"].asString());
+	if(!poseNode["Roll"].isNull())
+		data_.faceInfo.pose.roll = std::stof(poseNode["Roll"].asString());
+	if(!poseNode["Yaw"].isNull())
+		data_.faceInfo.pose.yaw = std::stof(poseNode["Yaw"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+std::string MonitorExaminationResult::getMessage()const
+{
+	return message_;
+}
+
+MonitorExaminationResult::Data MonitorExaminationResult::getData()const
+{
+	return data_;
+}
+
+std::string MonitorExaminationResult::getCode()const
+{
+	return code_;
+}
+

facebody/src/model/RecognizePublicFaceRequest.cc

@@ -39,6 +39,7 @@ void RecognizePublicFaceRequest::setTask(const std::vector<Task>& task)
 		auto taskObj = task.at(dep1);
 		std::string taskObjStr = "Task." + std::to_string(dep1 + 1);
 		setParameter(taskObjStr + ".ImageURL", taskObj.imageURL);
+		setParameter(taskObjStr + ".ImageData", taskObj.imageData);
 	}
 }
 

facebody/src/model/RecognizePublicFaceResult.cc

@@ -52,34 +52,34 @@ void RecognizePublicFaceResult::parse(const std::string &payload)
 		for (auto dataNodeElementsElementResultsResult : allResultsNode)
 		{
 			Data::Element::Result resultsObject;
-			if(!dataNodeElementsElementResultsResult["Label"].isNull())
-				resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
 			if(!dataNodeElementsElementResultsResult["Suggestion"].isNull())
 				resultsObject.suggestion = dataNodeElementsElementResultsResult["Suggestion"].asString();
 			if(!dataNodeElementsElementResultsResult["Rate"].isNull())
 				resultsObject.rate = std::stof(dataNodeElementsElementResultsResult["Rate"].asString());
+			if(!dataNodeElementsElementResultsResult["Label"].isNull())
+				resultsObject.label = dataNodeElementsElementResultsResult["Label"].asString();
 			auto allSubResultsNode = dataNodeElementsElementResultsResult["SubResults"]["SubResult"];
 			for (auto dataNodeElementsElementResultsResultSubResultsSubResult : allSubResultsNode)
 			{
 				Data::Element::Result::SubResult subResultsObject;
-				if(!dataNodeElementsElementResultsResultSubResultsSubResult["H"].isNull())
-					subResultsObject.h = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["H"].asString());
 				if(!dataNodeElementsElementResultsResultSubResultsSubResult["W"].isNull())
 					subResultsObject.w = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["W"].asString());
 				if(!dataNodeElementsElementResultsResultSubResultsSubResult["X"].isNull())
 					subResultsObject.x = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["X"].asString());
+				if(!dataNodeElementsElementResultsResultSubResultsSubResult["H"].isNull())
+					subResultsObject.h = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["H"].asString());
 				if(!dataNodeElementsElementResultsResultSubResultsSubResult["Y"].isNull())
 					subResultsObject.y = std::stof(dataNodeElementsElementResultsResultSubResultsSubResult["Y"].asString());
 				auto allFacesNode = dataNodeElementsElementResultsResultSubResultsSubResult["Faces"]["Face"];
 				for (auto dataNodeElementsElementResultsResultSubResultsSubResultFacesFace : allFacesNode)
 				{
 					Data::Element::Result::SubResult::Face facesObject;
+					if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].isNull())
+						facesObject.rate = std::stof(dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].asString());
 					if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Id"].isNull())
 						facesObject.id = dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Id"].asString();
 					if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Name"].isNull())
 						facesObject.name = dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Name"].asString();
-					if(!dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].isNull())
-						facesObject.rate = std::stof(dataNodeElementsElementResultsResultSubResultsSubResultFacesFace["Rate"].asString());
 					subResultsObject.faces.push_back(facesObject);
 				}
 				resultsObject.subResults.push_back(subResultsObject);