Release ScreenGC.

VERSION

@@ -1 +1 @@
-1.36.1586
+1.36.1587

imageprocess/CMakeLists.txt

@@ -37,6 +37,8 @@ set(imageprocess_public_header_model
 	include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayRequest.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayResult.h
+	include/alibabacloud/imageprocess/model/DetectLiverSteatosisRequest.h
+	include/alibabacloud/imageprocess/model/DetectLiverSteatosisResult.h
 	include/alibabacloud/imageprocess/model/DetectLungNoduleRequest.h
 	include/alibabacloud/imageprocess/model/DetectLungNoduleResult.h
 	include/alibabacloud/imageprocess/model/DetectLymphRequest.h
@@ -53,14 +55,22 @@ set(imageprocess_public_header_model
 	include/alibabacloud/imageprocess/model/FeedbackSessionResult.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultResult.h
+	include/alibabacloud/imageprocess/model/PredictCVDRequest.h
+	include/alibabacloud/imageprocess/model/PredictCVDResult.h
 	include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h
 	include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h
 	include/alibabacloud/imageprocess/model/RunMedQARequest.h
 	include/alibabacloud/imageprocess/model/RunMedQAResult.h
+	include/alibabacloud/imageprocess/model/ScreenCRCRequest.h
+	include/alibabacloud/imageprocess/model/ScreenCRCResult.h
 	include/alibabacloud/imageprocess/model/ScreenChestCTRequest.h
 	include/alibabacloud/imageprocess/model/ScreenChestCTResult.h
 	include/alibabacloud/imageprocess/model/ScreenECRequest.h
 	include/alibabacloud/imageprocess/model/ScreenECResult.h
+	include/alibabacloud/imageprocess/model/ScreenGCRequest.h
+	include/alibabacloud/imageprocess/model/ScreenGCResult.h
+	include/alibabacloud/imageprocess/model/ScreenLCRequest.h
+	include/alibabacloud/imageprocess/model/ScreenLCResult.h
 	include/alibabacloud/imageprocess/model/SegmentLymphNodeRequest.h
 	include/alibabacloud/imageprocess/model/SegmentLymphNodeResult.h
 	include/alibabacloud/imageprocess/model/SegmentOARRequest.h
@@ -88,6 +98,8 @@ set(imageprocess_src
 	src/model/DetectKneeKeypointXRayResult.cc
 	src/model/DetectKneeXRayRequest.cc
 	src/model/DetectKneeXRayResult.cc
+	src/model/DetectLiverSteatosisRequest.cc
+	src/model/DetectLiverSteatosisResult.cc
 	src/model/DetectLungNoduleRequest.cc
 	src/model/DetectLungNoduleResult.cc
 	src/model/DetectLymphRequest.cc
@@ -104,14 +116,22 @@ set(imageprocess_src
 	src/model/FeedbackSessionResult.cc
 	src/model/GetAsyncJobResultRequest.cc
 	src/model/GetAsyncJobResultResult.cc
+	src/model/PredictCVDRequest.cc
+	src/model/PredictCVDResult.cc
 	src/model/RunCTRegistrationRequest.cc
 	src/model/RunCTRegistrationResult.cc
 	src/model/RunMedQARequest.cc
 	src/model/RunMedQAResult.cc
+	src/model/ScreenCRCRequest.cc
+	src/model/ScreenCRCResult.cc
 	src/model/ScreenChestCTRequest.cc
 	src/model/ScreenChestCTResult.cc
 	src/model/ScreenECRequest.cc
 	src/model/ScreenECResult.cc
+	src/model/ScreenGCRequest.cc
+	src/model/ScreenGCResult.cc
+	src/model/ScreenLCRequest.cc
+	src/model/ScreenLCResult.cc
 	src/model/SegmentLymphNodeRequest.cc
 	src/model/SegmentLymphNodeResult.cc
 	src/model/SegmentOARRequest.cc

imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h

@@ -38,6 +38,8 @@
 #include "model/DetectKneeKeypointXRayResult.h"
 #include "model/DetectKneeXRayRequest.h"
 #include "model/DetectKneeXRayResult.h"
+#include "model/DetectLiverSteatosisRequest.h"
+#include "model/DetectLiverSteatosisResult.h"
 #include "model/DetectLungNoduleRequest.h"
 #include "model/DetectLungNoduleResult.h"
 #include "model/DetectLymphRequest.h"
@@ -54,14 +56,22 @@
 #include "model/FeedbackSessionResult.h"
 #include "model/GetAsyncJobResultRequest.h"
 #include "model/GetAsyncJobResultResult.h"
+#include "model/PredictCVDRequest.h"
+#include "model/PredictCVDResult.h"
 #include "model/RunCTRegistrationRequest.h"
 #include "model/RunCTRegistrationResult.h"
 #include "model/RunMedQARequest.h"
 #include "model/RunMedQAResult.h"
+#include "model/ScreenCRCRequest.h"
+#include "model/ScreenCRCResult.h"
 #include "model/ScreenChestCTRequest.h"
 #include "model/ScreenChestCTResult.h"
 #include "model/ScreenECRequest.h"
 #include "model/ScreenECResult.h"
+#include "model/ScreenGCRequest.h"
+#include "model/ScreenGCResult.h"
+#include "model/ScreenLCRequest.h"
+#include "model/ScreenLCResult.h"
 #include "model/SegmentLymphNodeRequest.h"
 #include "model/SegmentLymphNodeResult.h"
 #include "model/SegmentOARRequest.h"
@@ -103,6 +113,9 @@ namespace AlibabaCloud
 			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;
+			typedef Outcome<Error, Model::DetectLiverSteatosisResult> DetectLiverSteatosisOutcome;
+			typedef std::future<DetectLiverSteatosisOutcome> DetectLiverSteatosisOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::DetectLiverSteatosisRequest&, const DetectLiverSteatosisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLiverSteatosisAsyncHandler;
 			typedef Outcome<Error, Model::DetectLungNoduleResult> DetectLungNoduleOutcome;
 			typedef std::future<DetectLungNoduleOutcome> DetectLungNoduleOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::DetectLungNoduleRequest&, const DetectLungNoduleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLungNoduleAsyncHandler;
@@ -127,18 +140,30 @@ 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::PredictCVDResult> PredictCVDOutcome;
+			typedef std::future<PredictCVDOutcome> PredictCVDOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::PredictCVDRequest&, const PredictCVDOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictCVDAsyncHandler;
 			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::RunMedQAResult> RunMedQAOutcome;
 			typedef std::future<RunMedQAOutcome> RunMedQAOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::RunMedQARequest&, const RunMedQAOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunMedQAAsyncHandler;
+			typedef Outcome<Error, Model::ScreenCRCResult> ScreenCRCOutcome;
+			typedef std::future<ScreenCRCOutcome> ScreenCRCOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::ScreenCRCRequest&, const ScreenCRCOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScreenCRCAsyncHandler;
 			typedef Outcome<Error, Model::ScreenChestCTResult> ScreenChestCTOutcome;
 			typedef std::future<ScreenChestCTOutcome> ScreenChestCTOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::ScreenChestCTRequest&, const ScreenChestCTOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScreenChestCTAsyncHandler;
 			typedef Outcome<Error, Model::ScreenECResult> ScreenECOutcome;
 			typedef std::future<ScreenECOutcome> ScreenECOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::ScreenECRequest&, const ScreenECOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScreenECAsyncHandler;
+			typedef Outcome<Error, Model::ScreenGCResult> ScreenGCOutcome;
+			typedef std::future<ScreenGCOutcome> ScreenGCOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::ScreenGCRequest&, const ScreenGCOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScreenGCAsyncHandler;
+			typedef Outcome<Error, Model::ScreenLCResult> ScreenLCOutcome;
+			typedef std::future<ScreenLCOutcome> ScreenLCOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::ScreenLCRequest&, const ScreenLCOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScreenLCAsyncHandler;
 			typedef Outcome<Error, Model::SegmentLymphNodeResult> SegmentLymphNodeOutcome;
 			typedef std::future<SegmentLymphNodeOutcome> SegmentLymphNodeOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::SegmentLymphNodeRequest&, const SegmentLymphNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentLymphNodeAsyncHandler;
@@ -180,6 +205,9 @@ namespace AlibabaCloud
 			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;
+			DetectLiverSteatosisOutcome detectLiverSteatosis(const Model::DetectLiverSteatosisRequest &request)const;
+			void detectLiverSteatosisAsync(const Model::DetectLiverSteatosisRequest& request, const DetectLiverSteatosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectLiverSteatosisOutcomeCallable detectLiverSteatosisCallable(const Model::DetectLiverSteatosisRequest& request) const;
 			DetectLungNoduleOutcome detectLungNodule(const Model::DetectLungNoduleRequest &request)const;
 			void detectLungNoduleAsync(const Model::DetectLungNoduleRequest& request, const DetectLungNoduleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectLungNoduleOutcomeCallable detectLungNoduleCallable(const Model::DetectLungNoduleRequest& request) const;
@@ -204,18 +232,30 @@ 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;
+			PredictCVDOutcome predictCVD(const Model::PredictCVDRequest &request)const;
+			void predictCVDAsync(const Model::PredictCVDRequest& request, const PredictCVDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PredictCVDOutcomeCallable predictCVDCallable(const Model::PredictCVDRequest& 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;
 			RunMedQAOutcome runMedQA(const Model::RunMedQARequest &request)const;
 			void runMedQAAsync(const Model::RunMedQARequest& request, const RunMedQAAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RunMedQAOutcomeCallable runMedQACallable(const Model::RunMedQARequest& request) const;
+			ScreenCRCOutcome screenCRC(const Model::ScreenCRCRequest &request)const;
+			void screenCRCAsync(const Model::ScreenCRCRequest& request, const ScreenCRCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ScreenCRCOutcomeCallable screenCRCCallable(const Model::ScreenCRCRequest& request) const;
 			ScreenChestCTOutcome screenChestCT(const Model::ScreenChestCTRequest &request)const;
 			void screenChestCTAsync(const Model::ScreenChestCTRequest& request, const ScreenChestCTAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ScreenChestCTOutcomeCallable screenChestCTCallable(const Model::ScreenChestCTRequest& request) const;
 			ScreenECOutcome screenEC(const Model::ScreenECRequest &request)const;
 			void screenECAsync(const Model::ScreenECRequest& request, const ScreenECAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ScreenECOutcomeCallable screenECCallable(const Model::ScreenECRequest& request) const;
+			ScreenGCOutcome screenGC(const Model::ScreenGCRequest &request)const;
+			void screenGCAsync(const Model::ScreenGCRequest& request, const ScreenGCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ScreenGCOutcomeCallable screenGCCallable(const Model::ScreenGCRequest& request) const;
+			ScreenLCOutcome screenLC(const Model::ScreenLCRequest &request)const;
+			void screenLCAsync(const Model::ScreenLCRequest& request, const ScreenLCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ScreenLCOutcomeCallable screenLCCallable(const Model::ScreenLCRequest& request) const;
 			SegmentLymphNodeOutcome segmentLymphNode(const Model::SegmentLymphNodeRequest &request)const;
 			void segmentLymphNodeAsync(const Model::SegmentLymphNodeRequest& request, const SegmentLymphNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SegmentLymphNodeOutcomeCallable segmentLymphNodeCallable(const Model::SegmentLymphNodeRequest& request) const;

imageprocess/include/alibabacloud/imageprocess/model/DetectLiverSteatosisRequest.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_DETECTLIVERSTEATOSISREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISREQUEST_H_
+
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Imageprocess {
+namespace Model {
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectLiverSteatosisRequest : public RpcServiceRequest {
+public:
+	struct URLList {
+		std::string uRL;
+	};
+	DetectLiverSteatosisRequest();
+	~DetectLiverSteatosisRequest();
+	std::string getOrgName() const;
+	void setOrgName(const std::string &orgName);
+	std::string getSourceType() const;
+	void setSourceType(const std::string &sourceType);
+	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);
+
+private:
+	std::string orgName_;
+	std::string sourceType_;
+	std::string dataFormat_;
+	std::vector<URLList> uRLList_;
+	std::string orgId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Imageprocess
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectLiverSteatosisResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_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 DetectLiverSteatosisResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct DetectionsItem
+					{
+						long radius;
+						float liverSpleenDifference;
+						float liverSlice;
+						float liverHU;
+						std::string prediction;
+						float probability;
+						float spleenHU;
+						std::vector<std::string> spleenCenter;
+						float liverSpleenRatio;
+						float spleenVolume;
+						std::vector<std::string> rOI2Center;
+						std::vector<std::string> rOI3Center;
+						float spleenSlice;
+						float liverROI1;
+						std::vector<std::string> rOI1Center;
+						float liverVolume;
+						float spleenROI;
+						float liverROI2;
+						float liverROI3;
+					};
+					std::vector<std::string> origin;
+					std::vector<std::string> spacing;
+					std::vector<DetectionsItem> detections;
+				};
+
+
+				DetectLiverSteatosisResult();
+				explicit DetectLiverSteatosisResult(const std::string &payload);
+				~DetectLiverSteatosisResult();
+				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_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/PredictCVDRequest.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_PREDICTCVDREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDREQUEST_H_
+
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Imageprocess {
+namespace Model {
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT PredictCVDRequest : public RpcServiceRequest {
+public:
+	struct URLList {
+		std::string uRL;
+	};
+	PredictCVDRequest();
+	~PredictCVDRequest();
+	std::string getDataSourceType() const;
+	void setDataSourceType(const std::string &dataSourceType);
+	std::string getOrgName() const;
+	void setOrgName(const std::string &orgName);
+	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);
+
+private:
+	std::string dataSourceType_;
+	std::string orgName_;
+	std::string dataFormat_;
+	std::vector<URLList> uRLList_;
+	std::string orgId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Imageprocess
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/PredictCVDResult.h

@@ -0,0 +1,82 @@
+/*
+ * 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_PREDICTCVDRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDRESULT_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 PredictCVDResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Lesion
+					{
+						struct FeatureScore
+						{
+							std::vector<std::string> eatHUSTD;
+							std::vector<std::string> coronaryCalciumScore;
+							std::vector<std::string> rightLungLowattRatio;
+							std::vector<std::string> ascendAortaLength;
+							std::vector<std::string> myoEpiRatio;
+							std::vector<std::string> eatHUMean;
+							std::vector<std::string> leftLungLowattRatio;
+							std::vector<std::string> ascAoMaxDiam;
+							std::vector<std::string> eatVolume;
+							std::vector<std::string> coronaryCalciumVol;
+							std::vector<std::string> cardioThoracicRatio;
+							std::vector<std::string> deepFeature;
+							std::vector<std::string> aortaCalciumScore;
+							std::vector<std::string> aortaCalciumVolume;
+						};
+						FeatureScore featureScore;
+						float cVDProbability;
+						std::vector<std::string> resultURL;
+					};
+					Lesion lesion;
+				};
+
+
+				PredictCVDResult();
+				explicit PredictCVDResult(const std::string &payload);
+				~PredictCVDResult();
+				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_IMAGEPROCESS_MODEL_PREDICTCVDRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenCRCRequest.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_SCREENCRCREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCRCREQUEST_H_
+
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Imageprocess {
+namespace Model {
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenCRCRequest : public RpcServiceRequest {
+public:
+	struct URLList {
+		std::string uRL;
+	};
+	ScreenCRCRequest();
+	~ScreenCRCRequest();
+	std::string getDataSourceType() const;
+	void setDataSourceType(const std::string &dataSourceType);
+	std::string getOrgName() const;
+	void setOrgName(const std::string &orgName);
+	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);
+
+private:
+	std::string dataSourceType_;
+	std::string orgName_;
+	std::string dataFormat_;
+	std::vector<URLList> uRLList_;
+	std::string orgId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Imageprocess
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCRCREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenCRCResult.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_SCREENCRCRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCRCRESULT_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 ScreenCRCResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Lesion
+					{
+						std::string cRCVolume;
+						std::string colorectumVolume;
+						std::string mask;
+						std::string stage2Volume;
+						std::string probabilities;
+						std::string nonCRCVolumel;
+					};
+					Lesion lesion;
+				};
+
+
+				ScreenCRCResult();
+				explicit ScreenCRCResult(const std::string &payload);
+				~ScreenCRCResult();
+				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_IMAGEPROCESS_MODEL_SCREENCRCRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenGCRequest.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_SCREENGCREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENGCREQUEST_H_
+
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Imageprocess {
+namespace Model {
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenGCRequest : public RpcServiceRequest {
+public:
+	struct URLList {
+		std::string uRL;
+	};
+	ScreenGCRequest();
+	~ScreenGCRequest();
+	std::string getDataSourceType() const;
+	void setDataSourceType(const std::string &dataSourceType);
+	std::string getOrgName() const;
+	void setOrgName(const std::string &orgName);
+	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);
+
+private:
+	std::string dataSourceType_;
+	std::string orgName_;
+	std::string dataFormat_;
+	std::vector<URLList> uRLList_;
+	std::string orgId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Imageprocess
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENGCREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenGCResult.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_SCREENGCRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENGCRESULT_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 ScreenGCResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Lesion
+					{
+						std::string nonGCVolume;
+						std::string stomachVolume;
+						std::string gCVolume;
+						std::string mask;
+						std::string stage2Volume;
+						std::string probabilities;
+					};
+					Lesion lesion;
+				};
+
+
+				ScreenGCResult();
+				explicit ScreenGCResult(const std::string &payload);
+				~ScreenGCResult();
+				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_IMAGEPROCESS_MODEL_SCREENGCRESULT_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenLCRequest.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_SCREENLCREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCREQUEST_H_
+
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Imageprocess {
+namespace Model {
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenLCRequest : public RpcServiceRequest {
+public:
+	struct URLList {
+		std::string uRL;
+	};
+	ScreenLCRequest();
+	~ScreenLCRequest();
+	std::string getDataSourceType() const;
+	void setDataSourceType(const std::string &dataSourceType);
+	std::string getOrgName() const;
+	void setOrgName(const std::string &orgName);
+	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);
+
+private:
+	std::string dataSourceType_;
+	std::string orgName_;
+	std::string dataFormat_;
+	std::vector<URLList> uRLList_;
+	std::string orgId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Imageprocess
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/ScreenLCResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCRESULT_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCRESULT_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 ScreenLCResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Lesion
+					{
+						struct PatientLevelResult
+						{
+							float malignantNonHCCProb;
+							float hCCProb;
+							float tumorNonCystProb;
+							float cystProb;
+							std::string benignNonCystProb;
+						};
+						struct LesionListItem
+						{
+							std::string type;
+							float volume;
+							std::vector<std::string> recistEndpoints;
+							float malignancy;
+							std::vector<std::string> diameter;
+							long keySlice;
+						};
+						std::vector<LesionListItem> lesionList;
+						PatientLevelResult patientLevelResult;
+						std::string mask;
+						float liverVolume;
+					};
+					Lesion lesion;
+				};
+
+
+				ScreenLCResult();
+				explicit ScreenLCResult(const std::string &payload);
+				~ScreenLCResult();
+				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_IMAGEPROCESS_MODEL_SCREENLCRESULT_H_

imageprocess/src/ImageprocessClient.cc

@@ -339,6 +339,42 @@ ImageprocessClient::DetectKneeXRayOutcomeCallable ImageprocessClient::detectKnee
 	return task->get_future();
 }
 
+ImageprocessClient::DetectLiverSteatosisOutcome ImageprocessClient::detectLiverSteatosis(const DetectLiverSteatosisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectLiverSteatosisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectLiverSteatosisOutcome(DetectLiverSteatosisResult(outcome.result()));
+	else
+		return DetectLiverSteatosisOutcome(outcome.error());
+}
+
+void ImageprocessClient::detectLiverSteatosisAsync(const DetectLiverSteatosisRequest& request, const DetectLiverSteatosisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectLiverSteatosis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::DetectLiverSteatosisOutcomeCallable ImageprocessClient::detectLiverSteatosisCallable(const DetectLiverSteatosisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectLiverSteatosisOutcome()>>(
+			[this, request]()
+			{
+			return this->detectLiverSteatosis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::DetectLungNoduleOutcome ImageprocessClient::detectLungNodule(const DetectLungNoduleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +663,42 @@ ImageprocessClient::GetAsyncJobResultOutcomeCallable ImageprocessClient::getAsyn
 	return task->get_future();
 }
 
+ImageprocessClient::PredictCVDOutcome ImageprocessClient::predictCVD(const PredictCVDRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PredictCVDOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PredictCVDOutcome(PredictCVDResult(outcome.result()));
+	else
+		return PredictCVDOutcome(outcome.error());
+}
+
+void ImageprocessClient::predictCVDAsync(const PredictCVDRequest& request, const PredictCVDAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, predictCVD(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::PredictCVDOutcomeCallable ImageprocessClient::predictCVDCallable(const PredictCVDRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PredictCVDOutcome()>>(
+			[this, request]()
+			{
+			return this->predictCVD(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::RunCTRegistrationOutcome ImageprocessClient::runCTRegistration(const RunCTRegistrationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +771,42 @@ ImageprocessClient::RunMedQAOutcomeCallable ImageprocessClient::runMedQACallable
 	return task->get_future();
 }
 
+ImageprocessClient::ScreenCRCOutcome ImageprocessClient::screenCRC(const ScreenCRCRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ScreenCRCOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ScreenCRCOutcome(ScreenCRCResult(outcome.result()));
+	else
+		return ScreenCRCOutcome(outcome.error());
+}
+
+void ImageprocessClient::screenCRCAsync(const ScreenCRCRequest& request, const ScreenCRCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, screenCRC(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::ScreenCRCOutcomeCallable ImageprocessClient::screenCRCCallable(const ScreenCRCRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ScreenCRCOutcome()>>(
+			[this, request]()
+			{
+			return this->screenCRC(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::ScreenChestCTOutcome ImageprocessClient::screenChestCT(const ScreenChestCTRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +879,78 @@ ImageprocessClient::ScreenECOutcomeCallable ImageprocessClient::screenECCallable
 	return task->get_future();
 }
 
+ImageprocessClient::ScreenGCOutcome ImageprocessClient::screenGC(const ScreenGCRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ScreenGCOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ScreenGCOutcome(ScreenGCResult(outcome.result()));
+	else
+		return ScreenGCOutcome(outcome.error());
+}
+
+void ImageprocessClient::screenGCAsync(const ScreenGCRequest& request, const ScreenGCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, screenGC(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::ScreenGCOutcomeCallable ImageprocessClient::screenGCCallable(const ScreenGCRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ScreenGCOutcome()>>(
+			[this, request]()
+			{
+			return this->screenGC(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageprocessClient::ScreenLCOutcome ImageprocessClient::screenLC(const ScreenLCRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ScreenLCOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ScreenLCOutcome(ScreenLCResult(outcome.result()));
+	else
+		return ScreenLCOutcome(outcome.error());
+}
+
+void ImageprocessClient::screenLCAsync(const ScreenLCRequest& request, const ScreenLCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, screenLC(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageprocessClient::ScreenLCOutcomeCallable ImageprocessClient::screenLCCallable(const ScreenLCRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ScreenLCOutcome()>>(
+			[this, request]()
+			{
+			return this->screenLC(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ImageprocessClient::SegmentLymphNodeOutcome ImageprocessClient::segmentLymphNode(const SegmentLymphNodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

imageprocess/src/model/DetectLiverSteatosisRequest.cc

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

imageprocess/src/model/DetectLiverSteatosisResult.cc

@@ -0,0 +1,118 @@
+/*
+ * 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/DetectLiverSteatosisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+DetectLiverSteatosisResult::DetectLiverSteatosisResult() :
+	ServiceResult()
+{}
+
+DetectLiverSteatosisResult::DetectLiverSteatosisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectLiverSteatosisResult::~DetectLiverSteatosisResult()
+{}
+
+void DetectLiverSteatosisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allDetectionsNode = dataNode["Detections"]["DetectionsItem"];
+	for (auto dataNodeDetectionsDetectionsItem : allDetectionsNode)
+	{
+		Data::DetectionsItem detectionsItemObject;
+		if(!dataNodeDetectionsDetectionsItem["Radius"].isNull())
+			detectionsItemObject.radius = std::stol(dataNodeDetectionsDetectionsItem["Radius"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverSlice"].isNull())
+			detectionsItemObject.liverSlice = std::stof(dataNodeDetectionsDetectionsItem["LiverSlice"].asString());
+		if(!dataNodeDetectionsDetectionsItem["SpleenSlice"].isNull())
+			detectionsItemObject.spleenSlice = std::stof(dataNodeDetectionsDetectionsItem["SpleenSlice"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverVolume"].isNull())
+			detectionsItemObject.liverVolume = std::stof(dataNodeDetectionsDetectionsItem["LiverVolume"].asString());
+		if(!dataNodeDetectionsDetectionsItem["SpleenVolume"].isNull())
+			detectionsItemObject.spleenVolume = std::stof(dataNodeDetectionsDetectionsItem["SpleenVolume"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverHU"].isNull())
+			detectionsItemObject.liverHU = std::stof(dataNodeDetectionsDetectionsItem["LiverHU"].asString());
+		if(!dataNodeDetectionsDetectionsItem["SpleenHU"].isNull())
+			detectionsItemObject.spleenHU = std::stof(dataNodeDetectionsDetectionsItem["SpleenHU"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverROI1"].isNull())
+			detectionsItemObject.liverROI1 = std::stof(dataNodeDetectionsDetectionsItem["LiverROI1"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverROI2"].isNull())
+			detectionsItemObject.liverROI2 = std::stof(dataNodeDetectionsDetectionsItem["LiverROI2"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverROI3"].isNull())
+			detectionsItemObject.liverROI3 = std::stof(dataNodeDetectionsDetectionsItem["LiverROI3"].asString());
+		if(!dataNodeDetectionsDetectionsItem["SpleenROI"].isNull())
+			detectionsItemObject.spleenROI = std::stof(dataNodeDetectionsDetectionsItem["SpleenROI"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverSpleenDifference"].isNull())
+			detectionsItemObject.liverSpleenDifference = std::stof(dataNodeDetectionsDetectionsItem["LiverSpleenDifference"].asString());
+		if(!dataNodeDetectionsDetectionsItem["LiverSpleenRatio"].isNull())
+			detectionsItemObject.liverSpleenRatio = std::stof(dataNodeDetectionsDetectionsItem["LiverSpleenRatio"].asString());
+		if(!dataNodeDetectionsDetectionsItem["Prediction"].isNull())
+			detectionsItemObject.prediction = dataNodeDetectionsDetectionsItem["Prediction"].asString();
+		if(!dataNodeDetectionsDetectionsItem["Probability"].isNull())
+			detectionsItemObject.probability = std::stof(dataNodeDetectionsDetectionsItem["Probability"].asString());
+		auto allROI1Center = value["ROI1Center"]["ROI1Center"];
+		for (auto value : allROI1Center)
+			detectionsItemObject.rOI1Center.push_back(value.asString());
+		auto allROI2Center = value["ROI2Center"]["ROI2Center"];
+		for (auto value : allROI2Center)
+			detectionsItemObject.rOI2Center.push_back(value.asString());
+		auto allROI3Center = value["ROI3Center"]["ROI3Center"];
+		for (auto value : allROI3Center)
+			detectionsItemObject.rOI3Center.push_back(value.asString());
+		auto allSpleenCenter = value["SpleenCenter"]["SpleenCenter"];
+		for (auto value : allSpleenCenter)
+			detectionsItemObject.spleenCenter.push_back(value.asString());
+		data_.detections.push_back(detectionsItemObject);
+	}
+		auto allSpacing = dataNode["Spacing"]["Spacing"];
+		for (auto value : allSpacing)
+			data_.spacing.push_back(value.asString());
+		auto allOrigin = dataNode["Origin"]["Origin"];
+		for (auto value : allOrigin)
+			data_.origin.push_back(value.asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DetectLiverSteatosisResult::getMessage()const
+{
+	return message_;
+}
+
+DetectLiverSteatosisResult::Data DetectLiverSteatosisResult::getData()const
+{
+	return data_;
+}
+
+std::string DetectLiverSteatosisResult::getCode()const
+{
+	return code_;
+}
+

imageprocess/src/model/PredictCVDRequest.cc

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

imageprocess/src/model/PredictCVDResult.cc

@@ -0,0 +1,113 @@
+/*
+ * 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/PredictCVDResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+PredictCVDResult::PredictCVDResult() :
+	ServiceResult()
+{}
+
+PredictCVDResult::PredictCVDResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PredictCVDResult::~PredictCVDResult()
+{}
+
+void PredictCVDResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto lesionNode = dataNode["Lesion"];
+	if(!lesionNode["CVDProbability"].isNull())
+		data_.lesion.cVDProbability = std::stof(lesionNode["CVDProbability"].asString());
+	auto featureScoreNode = lesionNode["FeatureScore"];
+		auto allMyoEpiRatio = featureScoreNode["MyoEpiRatio"]["MyoEpiRatio"];
+		for (auto value : allMyoEpiRatio)
+			data_.lesion.featureScore.myoEpiRatio.push_back(value.asString());
+		auto allAscAoMaxDiam = featureScoreNode["AscAoMaxDiam"]["AscAoMaxDiam"];
+		for (auto value : allAscAoMaxDiam)
+			data_.lesion.featureScore.ascAoMaxDiam.push_back(value.asString());
+		auto allCoronaryCalciumVol = featureScoreNode["CoronaryCalciumVol"]["CoronaryCalciumVol"];
+		for (auto value : allCoronaryCalciumVol)
+			data_.lesion.featureScore.coronaryCalciumVol.push_back(value.asString());
+		auto allEatVolume = featureScoreNode["EatVolume"]["EatVolume"];
+		for (auto value : allEatVolume)
+			data_.lesion.featureScore.eatVolume.push_back(value.asString());
+		auto allAortaCalciumScore = featureScoreNode["AortaCalciumScore"]["AortaCalciumScore"];
+		for (auto value : allAortaCalciumScore)
+			data_.lesion.featureScore.aortaCalciumScore.push_back(value.asString());
+		auto allCardioThoracicRatio = featureScoreNode["CardioThoracicRatio"]["CardioThoracicRatio"];
+		for (auto value : allCardioThoracicRatio)
+			data_.lesion.featureScore.cardioThoracicRatio.push_back(value.asString());
+		auto allEatHUMean = featureScoreNode["EatHUMean"]["EatHUMean"];
+		for (auto value : allEatHUMean)
+			data_.lesion.featureScore.eatHUMean.push_back(value.asString());
+		auto allEatHUSTD = featureScoreNode["EatHUSTD"]["EatHUSTD"];
+		for (auto value : allEatHUSTD)
+			data_.lesion.featureScore.eatHUSTD.push_back(value.asString());
+		auto allRightLungLowattRatio = featureScoreNode["RightLungLowattRatio"]["RightLungLowattRatio"];
+		for (auto value : allRightLungLowattRatio)
+			data_.lesion.featureScore.rightLungLowattRatio.push_back(value.asString());
+		auto allAscendAortaLength = featureScoreNode["AscendAortaLength"]["AscendAortaLength"];
+		for (auto value : allAscendAortaLength)
+			data_.lesion.featureScore.ascendAortaLength.push_back(value.asString());
+		auto allLeftLungLowattRatio = featureScoreNode["LeftLungLowattRatio"]["LeftLungLowattRatio"];
+		for (auto value : allLeftLungLowattRatio)
+			data_.lesion.featureScore.leftLungLowattRatio.push_back(value.asString());
+		auto allDeepFeature = featureScoreNode["DeepFeature"]["DeepFeature"];
+		for (auto value : allDeepFeature)
+			data_.lesion.featureScore.deepFeature.push_back(value.asString());
+		auto allAortaCalciumVolume = featureScoreNode["AortaCalciumVolume"]["AortaCalciumVolume"];
+		for (auto value : allAortaCalciumVolume)
+			data_.lesion.featureScore.aortaCalciumVolume.push_back(value.asString());
+		auto allCoronaryCalciumScore = featureScoreNode["CoronaryCalciumScore"]["CoronaryCalciumScore"];
+		for (auto value : allCoronaryCalciumScore)
+			data_.lesion.featureScore.coronaryCalciumScore.push_back(value.asString());
+		auto allResultURL = lesionNode["ResultURL"]["ResultURL"];
+		for (auto value : allResultURL)
+			data_.lesion.resultURL.push_back(value.asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string PredictCVDResult::getMessage()const
+{
+	return message_;
+}
+
+PredictCVDResult::Data PredictCVDResult::getData()const
+{
+	return data_;
+}
+
+std::string PredictCVDResult::getCode()const
+{
+	return code_;
+}
+

imageprocess/src/model/ScreenCRCRequest.cc

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

imageprocess/src/model/ScreenCRCResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/ScreenCRCResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+ScreenCRCResult::ScreenCRCResult() :
+	ServiceResult()
+{}
+
+ScreenCRCResult::ScreenCRCResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ScreenCRCResult::~ScreenCRCResult()
+{}
+
+void ScreenCRCResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto lesionNode = dataNode["Lesion"];
+	if(!lesionNode["Probabilities"].isNull())
+		data_.lesion.probabilities = lesionNode["Probabilities"].asString();
+	if(!lesionNode["Stage2Volume"].isNull())
+		data_.lesion.stage2Volume = lesionNode["Stage2Volume"].asString();
+	if(!lesionNode["ColorectumVolume"].isNull())
+		data_.lesion.colorectumVolume = lesionNode["ColorectumVolume"].asString();
+	if(!lesionNode["CRCVolume"].isNull())
+		data_.lesion.cRCVolume = lesionNode["CRCVolume"].asString();
+	if(!lesionNode["NonCRCVolumel"].isNull())
+		data_.lesion.nonCRCVolumel = lesionNode["NonCRCVolumel"].asString();
+	if(!lesionNode["Mask"].isNull())
+		data_.lesion.mask = lesionNode["Mask"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ScreenCRCResult::getMessage()const
+{
+	return message_;
+}
+
+ScreenCRCResult::Data ScreenCRCResult::getData()const
+{
+	return data_;
+}
+
+std::string ScreenCRCResult::getCode()const
+{
+	return code_;
+}
+

imageprocess/src/model/ScreenGCRequest.cc

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

imageprocess/src/model/ScreenGCResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/ScreenGCResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+ScreenGCResult::ScreenGCResult() :
+	ServiceResult()
+{}
+
+ScreenGCResult::ScreenGCResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ScreenGCResult::~ScreenGCResult()
+{}
+
+void ScreenGCResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto lesionNode = dataNode["Lesion"];
+	if(!lesionNode["Probabilities"].isNull())
+		data_.lesion.probabilities = lesionNode["Probabilities"].asString();
+	if(!lesionNode["Stage2Volume"].isNull())
+		data_.lesion.stage2Volume = lesionNode["Stage2Volume"].asString();
+	if(!lesionNode["StomachVolume"].isNull())
+		data_.lesion.stomachVolume = lesionNode["StomachVolume"].asString();
+	if(!lesionNode["GCVolume"].isNull())
+		data_.lesion.gCVolume = lesionNode["GCVolume"].asString();
+	if(!lesionNode["NonGCVolume"].isNull())
+		data_.lesion.nonGCVolume = lesionNode["NonGCVolume"].asString();
+	if(!lesionNode["Mask"].isNull())
+		data_.lesion.mask = lesionNode["Mask"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ScreenGCResult::getMessage()const
+{
+	return message_;
+}
+
+ScreenGCResult::Data ScreenGCResult::getData()const
+{
+	return data_;
+}
+
+std::string ScreenGCResult::getCode()const
+{
+	return code_;
+}
+

imageprocess/src/model/ScreenLCRequest.cc

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

imageprocess/src/model/ScreenLCResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/ScreenLCResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageprocess;
+using namespace AlibabaCloud::Imageprocess::Model;
+
+ScreenLCResult::ScreenLCResult() :
+	ServiceResult()
+{}
+
+ScreenLCResult::ScreenLCResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ScreenLCResult::~ScreenLCResult()
+{}
+
+void ScreenLCResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto lesionNode = dataNode["Lesion"];
+	if(!lesionNode["Mask"].isNull())
+		data_.lesion.mask = lesionNode["Mask"].asString();
+	if(!lesionNode["LiverVolume"].isNull())
+		data_.lesion.liverVolume = std::stof(lesionNode["LiverVolume"].asString());
+	auto allLesionListNode = lesionNode["LesionList"]["LesionListItem"];
+	for (auto lesionNodeLesionListLesionListItem : allLesionListNode)
+	{
+		Data::Lesion::LesionListItem lesionListItemObject;
+		if(!lesionNodeLesionListLesionListItem["Type"].isNull())
+			lesionListItemObject.type = lesionNodeLesionListLesionListItem["Type"].asString();
+		if(!lesionNodeLesionListLesionListItem["Volume"].isNull())
+			lesionListItemObject.volume = std::stof(lesionNodeLesionListLesionListItem["Volume"].asString());
+		if(!lesionNodeLesionListLesionListItem["KeySlice"].isNull())
+			lesionListItemObject.keySlice = std::stol(lesionNodeLesionListLesionListItem["KeySlice"].asString());
+		if(!lesionNodeLesionListLesionListItem["Malignancy"].isNull())
+			lesionListItemObject.malignancy = std::stof(lesionNodeLesionListLesionListItem["Malignancy"].asString());
+		auto allRecistEndpoints = value["RecistEndpoints"]["RecistEndpoints"];
+		for (auto value : allRecistEndpoints)
+			lesionListItemObject.recistEndpoints.push_back(value.asString());
+		auto allDiameter = value["Diameter"]["Diameter"];
+		for (auto value : allDiameter)
+			lesionListItemObject.diameter.push_back(value.asString());
+		data_.lesion.lesionList.push_back(lesionListItemObject);
+	}
+	auto patientLevelResultNode = lesionNode["PatientLevelResult"];
+	if(!patientLevelResultNode["TumorNonCystProb"].isNull())
+		data_.lesion.patientLevelResult.tumorNonCystProb = std::stof(patientLevelResultNode["TumorNonCystProb"].asString());
+	if(!patientLevelResultNode["HCCProb"].isNull())
+		data_.lesion.patientLevelResult.hCCProb = std::stof(patientLevelResultNode["HCCProb"].asString());
+	if(!patientLevelResultNode["MalignantNonHCCProb"].isNull())
+		data_.lesion.patientLevelResult.malignantNonHCCProb = std::stof(patientLevelResultNode["MalignantNonHCCProb"].asString());
+	if(!patientLevelResultNode["BenignNonCystProb"].isNull())
+		data_.lesion.patientLevelResult.benignNonCystProb = patientLevelResultNode["BenignNonCystProb"].asString();
+	if(!patientLevelResultNode["CystProb"].isNull())
+		data_.lesion.patientLevelResult.cystProb = std::stof(patientLevelResultNode["CystProb"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ScreenLCResult::getMessage()const
+{
+	return message_;
+}
+
+ScreenLCResult::Data ScreenLCResult::getData()const
+{
+	return data_;
+}
+
+std::string ScreenLCResult::getCode()const
+{
+	return code_;
+}
+