Release DetectKneeKeypointXRay, DetectHipKeypointXRay, CalcCACS, RunCTRegistration, ClassifyFNF.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-09-09 Version: patch
+- Release DetectKneeKeypointXRay, DetectHipKeypointXRay, CalcCACS, RunCTRegistration, ClassifyFNF.
+
 2020-09-08 Version: patch
 - Supported backend interface for ICBU.
 

imageprocess/CMakeLists.txt

@@ -21,8 +21,16 @@ set(imageprocess_public_header
 	include/alibabacloud/imageprocess/ImageprocessExport.h )
 
 set(imageprocess_public_header_model 
+	include/alibabacloud/imageprocess/model/CalcCACSRequest.h
+	include/alibabacloud/imageprocess/model/CalcCACSResult.h
+	include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h
+	include/alibabacloud/imageprocess/model/ClassifyFNFResult.h
 	include/alibabacloud/imageprocess/model/DetectCovid19CadRequest.h
 	include/alibabacloud/imageprocess/model/DetectCovid19CadResult.h
+	include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h
+	include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h
+	include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h
+	include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayRequest.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayResult.h
 	include/alibabacloud/imageprocess/model/DetectLungNoduleRequest.h
@@ -31,13 +39,23 @@ set(imageprocess_public_header_model
 	include/alibabacloud/imageprocess/model/DetectSpineMRIResult.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultResult.h
+	include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h
+	include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h
 	include/alibabacloud/imageprocess/model/TranslateMedRequest.h
 	include/alibabacloud/imageprocess/model/TranslateMedResult.h )
 
 set(imageprocess_src 
 	src/ImageprocessClient.cc
+	src/model/CalcCACSRequest.cc
+	src/model/CalcCACSResult.cc
+	src/model/ClassifyFNFRequest.cc
+	src/model/ClassifyFNFResult.cc
 	src/model/DetectCovid19CadRequest.cc
 	src/model/DetectCovid19CadResult.cc
+	src/model/DetectHipKeypointXRayRequest.cc
+	src/model/DetectHipKeypointXRayResult.cc
+	src/model/DetectKneeKeypointXRayRequest.cc
+	src/model/DetectKneeKeypointXRayResult.cc
 	src/model/DetectKneeXRayRequest.cc
 	src/model/DetectKneeXRayResult.cc
 	src/model/DetectLungNoduleRequest.cc
@@ -46,6 +64,8 @@ set(imageprocess_src
 	src/model/DetectSpineMRIResult.cc
 	src/model/GetAsyncJobResultRequest.cc
 	src/model/GetAsyncJobResultResult.cc
+	src/model/RunCTRegistrationRequest.cc
+	src/model/RunCTRegistrationResult.cc
 	src/model/TranslateMedRequest.cc
 	src/model/TranslateMedResult.cc )
 

imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h

@@ -22,8 +22,16 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "ImageprocessExport.h"
+#include "model/CalcCACSRequest.h"
+#include "model/CalcCACSResult.h"
+#include "model/ClassifyFNFRequest.h"
+#include "model/ClassifyFNFResult.h"
 #include "model/DetectCovid19CadRequest.h"
 #include "model/DetectCovid19CadResult.h"
+#include "model/DetectHipKeypointXRayRequest.h"
+#include "model/DetectHipKeypointXRayResult.h"
+#include "model/DetectKneeKeypointXRayRequest.h"
+#include "model/DetectKneeKeypointXRayResult.h"
 #include "model/DetectKneeXRayRequest.h"
 #include "model/DetectKneeXRayResult.h"
 #include "model/DetectLungNoduleRequest.h"
@@ -32,6 +40,8 @@
 #include "model/DetectSpineMRIResult.h"
 #include "model/GetAsyncJobResultRequest.h"
 #include "model/GetAsyncJobResultResult.h"
+#include "model/RunCTRegistrationRequest.h"
+#include "model/RunCTRegistrationResult.h"
 #include "model/TranslateMedRequest.h"
 #include "model/TranslateMedResult.h"
 
@@ -43,9 +53,21 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_IMAGEPROCESS_EXPORT ImageprocessClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::CalcCACSResult> CalcCACSOutcome;
+			typedef std::future<CalcCACSOutcome> CalcCACSOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::CalcCACSRequest&, const CalcCACSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CalcCACSAsyncHandler;
+			typedef Outcome<Error, Model::ClassifyFNFResult> ClassifyFNFOutcome;
+			typedef std::future<ClassifyFNFOutcome> ClassifyFNFOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::ClassifyFNFRequest&, const ClassifyFNFOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClassifyFNFAsyncHandler;
 			typedef Outcome<Error, Model::DetectCovid19CadResult> DetectCovid19CadOutcome;
 			typedef std::future<DetectCovid19CadOutcome> DetectCovid19CadOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::DetectCovid19CadRequest&, const DetectCovid19CadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCovid19CadAsyncHandler;
+			typedef Outcome<Error, Model::DetectHipKeypointXRayResult> DetectHipKeypointXRayOutcome;
+			typedef std::future<DetectHipKeypointXRayOutcome> DetectHipKeypointXRayOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::DetectHipKeypointXRayRequest&, const DetectHipKeypointXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectHipKeypointXRayAsyncHandler;
+			typedef Outcome<Error, Model::DetectKneeKeypointXRayResult> DetectKneeKeypointXRayOutcome;
+			typedef std::future<DetectKneeKeypointXRayOutcome> DetectKneeKeypointXRayOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::DetectKneeKeypointXRayRequest&, const DetectKneeKeypointXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectKneeKeypointXRayAsyncHandler;
 			typedef Outcome<Error, Model::DetectKneeXRayResult> DetectKneeXRayOutcome;
 			typedef std::future<DetectKneeXRayOutcome> DetectKneeXRayOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::DetectKneeXRayRequest&, const DetectKneeXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectKneeXRayAsyncHandler;
@@ -58,6 +80,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
 			typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
+			typedef Outcome<Error, Model::RunCTRegistrationResult> RunCTRegistrationOutcome;
+			typedef std::future<RunCTRegistrationOutcome> RunCTRegistrationOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::RunCTRegistrationRequest&, const RunCTRegistrationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCTRegistrationAsyncHandler;
 			typedef Outcome<Error, Model::TranslateMedResult> TranslateMedOutcome;
 			typedef std::future<TranslateMedOutcome> TranslateMedOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::TranslateMedRequest&, const TranslateMedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateMedAsyncHandler;
@@ -66,9 +91,21 @@ namespace AlibabaCloud
 			ImageprocessClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			ImageprocessClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~ImageprocessClient();
+			CalcCACSOutcome calcCACS(const Model::CalcCACSRequest &request)const;
+			void calcCACSAsync(const Model::CalcCACSRequest& request, const CalcCACSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CalcCACSOutcomeCallable calcCACSCallable(const Model::CalcCACSRequest& request) const;
+			ClassifyFNFOutcome classifyFNF(const Model::ClassifyFNFRequest &request)const;
+			void classifyFNFAsync(const Model::ClassifyFNFRequest& request, const ClassifyFNFAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ClassifyFNFOutcomeCallable classifyFNFCallable(const Model::ClassifyFNFRequest& request) const;
 			DetectCovid19CadOutcome detectCovid19Cad(const Model::DetectCovid19CadRequest &request)const;
 			void detectCovid19CadAsync(const Model::DetectCovid19CadRequest& request, const DetectCovid19CadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectCovid19CadOutcomeCallable detectCovid19CadCallable(const Model::DetectCovid19CadRequest& request) const;
+			DetectHipKeypointXRayOutcome detectHipKeypointXRay(const Model::DetectHipKeypointXRayRequest &request)const;
+			void detectHipKeypointXRayAsync(const Model::DetectHipKeypointXRayRequest& request, const DetectHipKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectHipKeypointXRayOutcomeCallable detectHipKeypointXRayCallable(const Model::DetectHipKeypointXRayRequest& request) const;
+			DetectKneeKeypointXRayOutcome detectKneeKeypointXRay(const Model::DetectKneeKeypointXRayRequest &request)const;
+			void detectKneeKeypointXRayAsync(const Model::DetectKneeKeypointXRayRequest& request, const DetectKneeKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectKneeKeypointXRayOutcomeCallable detectKneeKeypointXRayCallable(const Model::DetectKneeKeypointXRayRequest& request) const;
 			DetectKneeXRayOutcome detectKneeXRay(const Model::DetectKneeXRayRequest &request)const;
 			void detectKneeXRayAsync(const Model::DetectKneeXRayRequest& request, const DetectKneeXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectKneeXRayOutcomeCallable detectKneeXRayCallable(const Model::DetectKneeXRayRequest& request) const;
@@ -81,6 +118,9 @@ namespace AlibabaCloud
 			GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
 			void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
+			RunCTRegistrationOutcome runCTRegistration(const Model::RunCTRegistrationRequest &request)const;
+			void runCTRegistrationAsync(const Model::RunCTRegistrationRequest& request, const RunCTRegistrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunCTRegistrationOutcomeCallable runCTRegistrationCallable(const Model::RunCTRegistrationRequest& request) const;
 			TranslateMedOutcome translateMed(const Model::TranslateMedRequest &request)const;
 			void translateMedAsync(const Model::TranslateMedRequest& request, const TranslateMedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateMedOutcomeCallable translateMedCallable(const Model::TranslateMedRequest& request) const;

imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSRequest : public RpcServiceRequest
+			{
+			public:
+				struct URLList
+				{
+					std::string uRL;
+				};
+
+			public:
+				CalcCACSRequest();
+				~CalcCACSRequest();
+
+				std::string getDataSourceType()const;
+				void setDataSourceType(const std::string& dataSourceType);
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::vector<URLList> getURLList()const;
+				void setURLList(const std::vector<URLList>& uRLList);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				bool getAsync()const;
+				void setAsync(bool async);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+
+            private:
+				std::string dataSourceType_;
+				std::string dataFormat_;
+				std::vector<URLList> uRLList_;
+				std::string orgId_;
+				bool async_;
+				std::string orgName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.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_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string score;
+				};
+
+
+				CalcCACSResult();
+				explicit CalcCACSResult(const std::string &payload);
+				~CalcCACSResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFRequest : public RpcServiceRequest
+			{
+
+			public:
+				ClassifyFNFRequest();
+				~ClassifyFNFRequest();
+
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getTracerId()const;
+				void setTracerId(const std::string& tracerId);
+
+            private:
+				std::string dataFormat_;
+				std::string orgId_;
+				std::string orgName_;
+				std::string imageUrl_;
+				std::string tracerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct FracturesItem
+					{
+						struct Tag
+						{
+							std::string label;
+						};
+						float value;
+						Tag tag;
+						std::vector<std::string> boxes;
+					};
+					std::string orgId;
+					std::vector<FracturesItem> fractures;
+					std::string imageUrl;
+					std::string orgName;
+				};
+
+
+				ClassifyFNFResult();
+				explicit ClassifyFNFResult(const std::string &payload);
+				~ClassifyFNFResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectHipKeypointXRayRequest();
+				~DetectHipKeypointXRayRequest();
+
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getTracerId()const;
+				void setTracerId(const std::string& tracerId);
+
+            private:
+				std::string dataFormat_;
+				std::string orgId_;
+				std::string orgName_;
+				std::string imageUrl_;
+				std::string tracerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h

@@ -0,0 +1,69 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct KeyPointsItem
+					{
+						struct Tag
+						{
+							std::string label;
+							std::string direction;
+						};
+						std::vector<std::string> coordinates;
+						float value;
+						Tag tag;
+					};
+					std::string orgId;
+					std::vector<KeyPointsItem> keyPoints;
+					std::string imageUrl;
+					std::string orgName;
+				};
+
+
+				DetectHipKeypointXRayResult();
+				explicit DetectHipKeypointXRayResult(const std::string &payload);
+				~DetectHipKeypointXRayResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h

@@ -0,0 +1,60 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectKneeKeypointXRayRequest();
+				~DetectKneeKeypointXRayRequest();
+
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getTracerId()const;
+				void setTracerId(const std::string& tracerId);
+
+            private:
+				std::string dataFormat_;
+				std::string orgId_;
+				std::string orgName_;
+				std::string imageUrl_;
+				std::string tracerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h

@@ -0,0 +1,69 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct KeyPointsItem
+					{
+						struct Tag
+						{
+							std::string label;
+							std::string direction;
+						};
+						std::vector<std::string> coordinates;
+						float value;
+						Tag tag;
+					};
+					std::string orgId;
+					std::vector<KeyPointsItem> keyPoints;
+					std::string imageUrl;
+					std::string orgName;
+				};
+
+
+				DetectKneeKeypointXRayResult();
+				explicit DetectKneeKeypointXRayResult(const std::string &payload);
+				~DetectKneeKeypointXRayResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h

@@ -0,0 +1,75 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationRequest : public RpcServiceRequest
+			{
+			public:
+				struct ReferenceList
+				{
+					std::string referenceURL;
+				};
+				struct FloatingList
+				{
+					std::string floatingURL;
+				};
+
+			public:
+				RunCTRegistrationRequest();
+				~RunCTRegistrationRequest();
+
+				std::string getDataSourceType()const;
+				void setDataSourceType(const std::string& dataSourceType);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+				std::vector<ReferenceList> getReferenceList()const;
+				void setReferenceList(const std::vector<ReferenceList>& referenceList);
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				bool getAsync()const;
+				void setAsync(bool async);
+				std::vector<FloatingList> getFloatingList()const;
+				void setFloatingList(const std::vector<FloatingList>& floatingList);
+
+            private:
+				std::string dataSourceType_;
+				std::string orgName_;
+				std::vector<ReferenceList> referenceList_;
+				std::string dataFormat_;
+				std::string orgId_;
+				bool async_;
+				std::vector<FloatingList> floatingList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string nUrl;
+					std::string dUrl;
+				};
+
+
+				RunCTRegistrationResult();
+				explicit RunCTRegistrationResult(const std::string &payload);
+				~RunCTRegistrationResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_

imageprocess/src/ImageprocessClient.cc

@@ -51,6 +51,78 @@ ImageprocessClient::ImageprocessClient(const std::string & accessKeyId, const st
 ImageprocessClient::~ImageprocessClient()
 {}
 
+ImageprocessClient::CalcCACSOutcome ImageprocessClient::calcCACS(const CalcCACSRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CalcCACSOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CalcCACSOutcome(CalcCACSResult(outcome.result()));
+	else
+		return CalcCACSOutcome(outcome.error());
+}
+
+void ImageprocessClient::calcCACSAsync(const CalcCACSRequest& request, const CalcCACSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, calcCACS(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::CalcCACSOutcomeCallable ImageprocessClient::calcCACSCallable(const CalcCACSRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CalcCACSOutcome()>>(
+			[this, request]()
+			{
+			return this->calcCACS(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageprocessClient::ClassifyFNFOutcome ImageprocessClient::classifyFNF(const ClassifyFNFRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ClassifyFNFOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ClassifyFNFOutcome(ClassifyFNFResult(outcome.result()));
+	else
+		return ClassifyFNFOutcome(outcome.error());
+}
+
+void ImageprocessClient::classifyFNFAsync(const ClassifyFNFRequest& request, const ClassifyFNFAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, classifyFNF(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::ClassifyFNFOutcomeCallable ImageprocessClient::classifyFNFCallable(const ClassifyFNFRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ClassifyFNFOutcome()>>(
+			[this, request]()
+			{
+			return this->classifyFNF(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::DetectCovid19CadOutcome ImageprocessClient::detectCovid19Cad(const DetectCovid19CadRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -87,6 +159,78 @@ ImageprocessClient::DetectCovid19CadOutcomeCallable ImageprocessClient::detectCo
 	return task->get_future();
 }
 
+ImageprocessClient::DetectHipKeypointXRayOutcome ImageprocessClient::detectHipKeypointXRay(const DetectHipKeypointXRayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectHipKeypointXRayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectHipKeypointXRayOutcome(DetectHipKeypointXRayResult(outcome.result()));
+	else
+		return DetectHipKeypointXRayOutcome(outcome.error());
+}
+
+void ImageprocessClient::detectHipKeypointXRayAsync(const DetectHipKeypointXRayRequest& request, const DetectHipKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectHipKeypointXRay(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::DetectHipKeypointXRayOutcomeCallable ImageprocessClient::detectHipKeypointXRayCallable(const DetectHipKeypointXRayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectHipKeypointXRayOutcome()>>(
+			[this, request]()
+			{
+			return this->detectHipKeypointXRay(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageprocessClient::DetectKneeKeypointXRayOutcome ImageprocessClient::detectKneeKeypointXRay(const DetectKneeKeypointXRayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectKneeKeypointXRayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectKneeKeypointXRayOutcome(DetectKneeKeypointXRayResult(outcome.result()));
+	else
+		return DetectKneeKeypointXRayOutcome(outcome.error());
+}
+
+void ImageprocessClient::detectKneeKeypointXRayAsync(const DetectKneeKeypointXRayRequest& request, const DetectKneeKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectKneeKeypointXRay(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::DetectKneeKeypointXRayOutcomeCallable ImageprocessClient::detectKneeKeypointXRayCallable(const DetectKneeKeypointXRayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectKneeKeypointXRayOutcome()>>(
+			[this, request]()
+			{
+			return this->detectKneeKeypointXRay(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::DetectKneeXRayOutcome ImageprocessClient::detectKneeXRay(const DetectKneeXRayRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +375,42 @@ ImageprocessClient::GetAsyncJobResultOutcomeCallable ImageprocessClient::getAsyn
 	return task->get_future();
 }
 
+ImageprocessClient::RunCTRegistrationOutcome ImageprocessClient::runCTRegistration(const RunCTRegistrationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RunCTRegistrationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RunCTRegistrationOutcome(RunCTRegistrationResult(outcome.result()));
+	else
+		return RunCTRegistrationOutcome(outcome.error());
+}
+
+void ImageprocessClient::runCTRegistrationAsync(const RunCTRegistrationRequest& request, const RunCTRegistrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, runCTRegistration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::RunCTRegistrationOutcomeCallable ImageprocessClient::runCTRegistrationCallable(const RunCTRegistrationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RunCTRegistrationOutcome()>>(
+			[this, request]()
+			{
+			return this->runCTRegistration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::TranslateMedOutcome ImageprocessClient::translateMed(const TranslateMedRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

imageprocess/src/model/CalcCACSRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/imageprocess/model/CalcCACSRequest.h>
+
+using AlibabaCloud::Imageprocess::Model::CalcCACSRequest;
+
+CalcCACSRequest::CalcCACSRequest() :
+	RpcServiceRequest("imageprocess", "2020-03-20", "CalcCACS")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CalcCACSRequest::~CalcCACSRequest()
+{}
+
+std::string CalcCACSRequest::getDataSourceType()const
+{
+	return dataSourceType_;
+}
+
+void CalcCACSRequest::setDataSourceType(const std::string& dataSourceType)
+{
+	dataSourceType_ = dataSourceType;
+	setBodyParameter("DataSourceType", dataSourceType);
+}
+
+std::string CalcCACSRequest::getDataFormat()const
+{
+	return dataFormat_;
+}
+
+void CalcCACSRequest::setDataFormat(const std::string& dataFormat)
+{
+	dataFormat_ = dataFormat;
+	setBodyParameter("DataFormat", dataFormat);
+}
+
+std::vector<CalcCACSRequest::URLList> CalcCACSRequest::getURLList()const
+{
+	return uRLList_;
+}
+
+void CalcCACSRequest::setURLList(const std::vector<URLList>& uRLList)
+{
+	uRLList_ = uRLList;
+	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
+		auto uRLListObj = uRLList.at(dep1);
+		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
+		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+	}
+}
+
+std::string CalcCACSRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void CalcCACSRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setBodyParameter("OrgId", orgId);
+}
+
+bool CalcCACSRequest::getAsync()const
+{
+	return async_;
+}
+
+void CalcCACSRequest::setAsync(bool async)
+{
+	async_ = async;
+	setBodyParameter("Async", async ? "true" : "false");
+}
+
+std::string CalcCACSRequest::getOrgName()const
+{
+	return orgName_;
+}
+
+void CalcCACSRequest::setOrgName(const std::string& orgName)
+{
+	orgName_ = orgName;
+	setBodyParameter("OrgName", orgName);
+}
+

imageprocess/src/model/CalcCACSResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageprocess/model/CalcCACSResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+CalcCACSResult::CalcCACSResult() :
+	ServiceResult()
+{}
+
+CalcCACSResult::CalcCACSResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CalcCACSResult::~CalcCACSResult()
+{}
+
+void CalcCACSResult::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["Score"].isNull())
+		data_.score = dataNode["Score"].asString();
+
+}
+
+CalcCACSResult::Data CalcCACSResult::getData()const
+{
+	return data_;
+}
+

imageprocess/src/model/ClassifyFNFRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/imageprocess/model/ClassifyFNFRequest.h>
+
+using AlibabaCloud::Imageprocess::Model::ClassifyFNFRequest;
+
+ClassifyFNFRequest::ClassifyFNFRequest() :
+	RpcServiceRequest("imageprocess", "2020-03-20", "ClassifyFNF")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ClassifyFNFRequest::~ClassifyFNFRequest()
+{}
+
+std::string ClassifyFNFRequest::getDataFormat()const
+{
+	return dataFormat_;
+}
+
+void ClassifyFNFRequest::setDataFormat(const std::string& dataFormat)
+{
+	dataFormat_ = dataFormat;
+	setBodyParameter("DataFormat", dataFormat);
+}
+
+std::string ClassifyFNFRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void ClassifyFNFRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setBodyParameter("OrgId", orgId);
+}
+
+std::string ClassifyFNFRequest::getOrgName()const
+{
+	return orgName_;
+}
+
+void ClassifyFNFRequest::setOrgName(const std::string& orgName)
+{
+	orgName_ = orgName;
+	setBodyParameter("OrgName", orgName);
+}
+
+std::string ClassifyFNFRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void ClassifyFNFRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string ClassifyFNFRequest::getTracerId()const
+{
+	return tracerId_;
+}
+
+void ClassifyFNFRequest::setTracerId(const std::string& tracerId)
+{
+	tracerId_ = tracerId;
+	setBodyParameter("TracerId", tracerId);
+}
+

imageprocess/src/model/ClassifyFNFResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/imageprocess/model/ClassifyFNFResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+ClassifyFNFResult::ClassifyFNFResult() :
+	ServiceResult()
+{}
+
+ClassifyFNFResult::ClassifyFNFResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ClassifyFNFResult::~ClassifyFNFResult()
+{}
+
+void ClassifyFNFResult::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["ImageUrl"].isNull())
+		data_.imageUrl = dataNode["ImageUrl"].asString();
+	if(!dataNode["OrgId"].isNull())
+		data_.orgId = dataNode["OrgId"].asString();
+	if(!dataNode["OrgName"].isNull())
+		data_.orgName = dataNode["OrgName"].asString();
+	auto allFracturesNode = dataNode["Fractures"]["FracturesItem"];
+	for (auto dataNodeFracturesFracturesItem : allFracturesNode)
+	{
+		Data::FracturesItem fracturesItemObject;
+		if(!dataNodeFracturesFracturesItem["Value"].isNull())
+			fracturesItemObject.value = std::stof(dataNodeFracturesFracturesItem["Value"].asString());
+		auto tagNode = value["Tag"];
+		if(!tagNode["Label"].isNull())
+			fracturesItemObject.tag.label = tagNode["Label"].asString();
+		auto allBoxes = value["Boxes"]["Boxes"];
+		for (auto value : allBoxes)
+			fracturesItemObject.boxes.push_back(value.asString());
+		data_.fractures.push_back(fracturesItemObject);
+	}
+
+}
+
+ClassifyFNFResult::Data ClassifyFNFResult::getData()const
+{
+	return data_;
+}
+

imageprocess/src/model/DetectHipKeypointXRayRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/imageprocess/model/DetectHipKeypointXRayRequest.h>
+
+using AlibabaCloud::Imageprocess::Model::DetectHipKeypointXRayRequest;
+
+DetectHipKeypointXRayRequest::DetectHipKeypointXRayRequest() :
+	RpcServiceRequest("imageprocess", "2020-03-20", "DetectHipKeypointXRay")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectHipKeypointXRayRequest::~DetectHipKeypointXRayRequest()
+{}
+
+std::string DetectHipKeypointXRayRequest::getDataFormat()const
+{
+	return dataFormat_;
+}
+
+void DetectHipKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
+{
+	dataFormat_ = dataFormat;
+	setBodyParameter("DataFormat", dataFormat);
+}
+
+std::string DetectHipKeypointXRayRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void DetectHipKeypointXRayRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setBodyParameter("OrgId", orgId);
+}
+
+std::string DetectHipKeypointXRayRequest::getOrgName()const
+{
+	return orgName_;
+}
+
+void DetectHipKeypointXRayRequest::setOrgName(const std::string& orgName)
+{
+	orgName_ = orgName;
+	setBodyParameter("OrgName", orgName);
+}
+
+std::string DetectHipKeypointXRayRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void DetectHipKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string DetectHipKeypointXRayRequest::getTracerId()const
+{
+	return tracerId_;
+}
+
+void DetectHipKeypointXRayRequest::setTracerId(const std::string& tracerId)
+{
+	tracerId_ = tracerId;
+	setBodyParameter("TracerId", tracerId);
+}
+

imageprocess/src/model/DetectHipKeypointXRayResult.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/imageprocess/model/DetectHipKeypointXRayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+DetectHipKeypointXRayResult::DetectHipKeypointXRayResult() :
+	ServiceResult()
+{}
+
+DetectHipKeypointXRayResult::DetectHipKeypointXRayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectHipKeypointXRayResult::~DetectHipKeypointXRayResult()
+{}
+
+void DetectHipKeypointXRayResult::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["ImageUrl"].isNull())
+		data_.imageUrl = dataNode["ImageUrl"].asString();
+	if(!dataNode["OrgId"].isNull())
+		data_.orgId = dataNode["OrgId"].asString();
+	if(!dataNode["OrgName"].isNull())
+		data_.orgName = dataNode["OrgName"].asString();
+	auto allKeyPointsNode = dataNode["KeyPoints"]["KeyPointsItem"];
+	for (auto dataNodeKeyPointsKeyPointsItem : allKeyPointsNode)
+	{
+		Data::KeyPointsItem keyPointsItemObject;
+		if(!dataNodeKeyPointsKeyPointsItem["Value"].isNull())
+			keyPointsItemObject.value = std::stof(dataNodeKeyPointsKeyPointsItem["Value"].asString());
+		auto tagNode = value["Tag"];
+		if(!tagNode["Direction"].isNull())
+			keyPointsItemObject.tag.direction = tagNode["Direction"].asString();
+		if(!tagNode["Label"].isNull())
+			keyPointsItemObject.tag.label = tagNode["Label"].asString();
+		auto allCoordinates = value["Coordinates"]["Coordinate"];
+		for (auto value : allCoordinates)
+			keyPointsItemObject.coordinates.push_back(value.asString());
+		data_.keyPoints.push_back(keyPointsItemObject);
+	}
+
+}
+
+DetectHipKeypointXRayResult::Data DetectHipKeypointXRayResult::getData()const
+{
+	return data_;
+}
+

imageprocess/src/model/DetectKneeKeypointXRayRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/imageprocess/model/DetectKneeKeypointXRayRequest.h>
+
+using AlibabaCloud::Imageprocess::Model::DetectKneeKeypointXRayRequest;
+
+DetectKneeKeypointXRayRequest::DetectKneeKeypointXRayRequest() :
+	RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeKeypointXRay")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectKneeKeypointXRayRequest::~DetectKneeKeypointXRayRequest()
+{}
+
+std::string DetectKneeKeypointXRayRequest::getDataFormat()const
+{
+	return dataFormat_;
+}
+
+void DetectKneeKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
+{
+	dataFormat_ = dataFormat;
+	setBodyParameter("DataFormat", dataFormat);
+}
+
+std::string DetectKneeKeypointXRayRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void DetectKneeKeypointXRayRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setBodyParameter("OrgId", orgId);
+}
+
+std::string DetectKneeKeypointXRayRequest::getOrgName()const
+{
+	return orgName_;
+}
+
+void DetectKneeKeypointXRayRequest::setOrgName(const std::string& orgName)
+{
+	orgName_ = orgName;
+	setBodyParameter("OrgName", orgName);
+}
+
+std::string DetectKneeKeypointXRayRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void DetectKneeKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string DetectKneeKeypointXRayRequest::getTracerId()const
+{
+	return tracerId_;
+}
+
+void DetectKneeKeypointXRayRequest::setTracerId(const std::string& tracerId)
+{
+	tracerId_ = tracerId;
+	setBodyParameter("TracerId", tracerId);
+}
+

imageprocess/src/model/DetectKneeKeypointXRayResult.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/imageprocess/model/DetectKneeKeypointXRayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+DetectKneeKeypointXRayResult::DetectKneeKeypointXRayResult() :
+	ServiceResult()
+{}
+
+DetectKneeKeypointXRayResult::DetectKneeKeypointXRayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectKneeKeypointXRayResult::~DetectKneeKeypointXRayResult()
+{}
+
+void DetectKneeKeypointXRayResult::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["ImageUrl"].isNull())
+		data_.imageUrl = dataNode["ImageUrl"].asString();
+	if(!dataNode["OrgId"].isNull())
+		data_.orgId = dataNode["OrgId"].asString();
+	if(!dataNode["OrgName"].isNull())
+		data_.orgName = dataNode["OrgName"].asString();
+	auto allKeyPointsNode = dataNode["KeyPoints"]["KeyPointsItem"];
+	for (auto dataNodeKeyPointsKeyPointsItem : allKeyPointsNode)
+	{
+		Data::KeyPointsItem keyPointsItemObject;
+		if(!dataNodeKeyPointsKeyPointsItem["Value"].isNull())
+			keyPointsItemObject.value = std::stof(dataNodeKeyPointsKeyPointsItem["Value"].asString());
+		auto tagNode = value["Tag"];
+		if(!tagNode["Direction"].isNull())
+			keyPointsItemObject.tag.direction = tagNode["Direction"].asString();
+		if(!tagNode["Label"].isNull())
+			keyPointsItemObject.tag.label = tagNode["Label"].asString();
+		auto allCoordinates = value["Coordinates"]["Coordinate"];
+		for (auto value : allCoordinates)
+			keyPointsItemObject.coordinates.push_back(value.asString());
+		data_.keyPoints.push_back(keyPointsItemObject);
+	}
+
+}
+
+DetectKneeKeypointXRayResult::Data DetectKneeKeypointXRayResult::getData()const
+{
+	return data_;
+}
+

imageprocess/src/model/RunCTRegistrationRequest.cc

@@ -0,0 +1,114 @@
+/*
+ * 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/imageprocess/model/RunCTRegistrationRequest.h>
+
+using AlibabaCloud::Imageprocess::Model::RunCTRegistrationRequest;
+
+RunCTRegistrationRequest::RunCTRegistrationRequest() :
+	RpcServiceRequest("imageprocess", "2020-03-20", "RunCTRegistration")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RunCTRegistrationRequest::~RunCTRegistrationRequest()
+{}
+
+std::string RunCTRegistrationRequest::getDataSourceType()const
+{
+	return dataSourceType_;
+}
+
+void RunCTRegistrationRequest::setDataSourceType(const std::string& dataSourceType)
+{
+	dataSourceType_ = dataSourceType;
+	setBodyParameter("DataSourceType", dataSourceType);
+}
+
+std::string RunCTRegistrationRequest::getOrgName()const
+{
+	return orgName_;
+}
+
+void RunCTRegistrationRequest::setOrgName(const std::string& orgName)
+{
+	orgName_ = orgName;
+	setBodyParameter("OrgName", orgName);
+}
+
+std::vector<RunCTRegistrationRequest::ReferenceList> RunCTRegistrationRequest::getReferenceList()const
+{
+	return referenceList_;
+}
+
+void RunCTRegistrationRequest::setReferenceList(const std::vector<ReferenceList>& referenceList)
+{
+	referenceList_ = referenceList;
+	for(int dep1 = 0; dep1!= referenceList.size(); dep1++) {
+		auto referenceListObj = referenceList.at(dep1);
+		std::string referenceListObjStr = "ReferenceList." + std::to_string(dep1 + 1);
+		setParameter(referenceListObjStr + ".ReferenceURL", referenceListObj.referenceURL);
+	}
+}
+
+std::string RunCTRegistrationRequest::getDataFormat()const
+{
+	return dataFormat_;
+}
+
+void RunCTRegistrationRequest::setDataFormat(const std::string& dataFormat)
+{
+	dataFormat_ = dataFormat;
+	setBodyParameter("DataFormat", dataFormat);
+}
+
+std::string RunCTRegistrationRequest::getOrgId()const
+{
+	return orgId_;
+}
+
+void RunCTRegistrationRequest::setOrgId(const std::string& orgId)
+{
+	orgId_ = orgId;
+	setBodyParameter("OrgId", orgId);
+}
+
+bool RunCTRegistrationRequest::getAsync()const
+{
+	return async_;
+}
+
+void RunCTRegistrationRequest::setAsync(bool async)
+{
+	async_ = async;
+	setBodyParameter("Async", async ? "true" : "false");
+}
+
+std::vector<RunCTRegistrationRequest::FloatingList> RunCTRegistrationRequest::getFloatingList()const
+{
+	return floatingList_;
+}
+
+void RunCTRegistrationRequest::setFloatingList(const std::vector<FloatingList>& floatingList)
+{
+	floatingList_ = floatingList;
+	for(int dep1 = 0; dep1!= floatingList.size(); dep1++) {
+		auto floatingListObj = floatingList.at(dep1);
+		std::string floatingListObjStr = "FloatingList." + std::to_string(dep1 + 1);
+		setParameter(floatingListObjStr + ".FloatingURL", floatingListObj.floatingURL);
+	}
+}
+

imageprocess/src/model/RunCTRegistrationResult.cc

@@ -0,0 +1,54 @@
+/*
+ * 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/imageprocess/model/RunCTRegistrationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+RunCTRegistrationResult::RunCTRegistrationResult() :
+	ServiceResult()
+{}
+
+RunCTRegistrationResult::RunCTRegistrationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RunCTRegistrationResult::~RunCTRegistrationResult()
+{}
+
+void RunCTRegistrationResult::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["DUrl"].isNull())
+		data_.dUrl = dataNode["DUrl"].asString();
+	if(!dataNode["NUrl"].isNull())
+		data_.nUrl = dataNode["NUrl"].asString();
+
+}
+
+RunCTRegistrationResult::Data RunCTRegistrationResult::getData()const
+{
+	return data_;
+}
+