From a3ccdb3f65b2415b288c5d543be88b4a7b9d4685 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Wed, 9 Sep 2020 07:48:43 +0000 Subject: [PATCH] Release DetectKneeKeypointXRay, DetectHipKeypointXRay, CalcCACS, RunCTRegistration, ClassifyFNF. --- CHANGELOG | 3 + imageprocess/CMakeLists.txt | 20 ++ .../imageprocess/ImageprocessClient.h | 40 ++++ .../imageprocess/model/CalcCACSRequest.h | 68 +++++++ .../imageprocess/model/CalcCACSResult.h | 55 ++++++ .../imageprocess/model/ClassifyFNFRequest.h | 60 ++++++ .../imageprocess/model/ClassifyFNFResult.h | 68 +++++++ .../model/DetectHipKeypointXRayRequest.h | 60 ++++++ .../model/DetectHipKeypointXRayResult.h | 69 +++++++ .../model/DetectKneeKeypointXRayRequest.h | 60 ++++++ .../model/DetectKneeKeypointXRayResult.h | 69 +++++++ .../model/RunCTRegistrationRequest.h | 75 ++++++++ .../model/RunCTRegistrationResult.h | 56 ++++++ imageprocess/src/ImageprocessClient.cc | 180 ++++++++++++++++++ imageprocess/src/model/CalcCACSRequest.cc | 99 ++++++++++ imageprocess/src/model/CalcCACSResult.cc | 52 +++++ imageprocess/src/model/ClassifyFNFRequest.cc | 84 ++++++++ imageprocess/src/model/ClassifyFNFResult.cc | 70 +++++++ .../src/model/DetectHipKeypointXRayRequest.cc | 84 ++++++++ .../src/model/DetectHipKeypointXRayResult.cc | 72 +++++++ .../model/DetectKneeKeypointXRayRequest.cc | 84 ++++++++ .../src/model/DetectKneeKeypointXRayResult.cc | 72 +++++++ .../src/model/RunCTRegistrationRequest.cc | 114 +++++++++++ .../src/model/RunCTRegistrationResult.cc | 54 ++++++ 24 files changed, 1668 insertions(+) create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFResult.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h create mode 100644 imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h create mode 100644 imageprocess/src/model/CalcCACSRequest.cc create mode 100644 imageprocess/src/model/CalcCACSResult.cc create mode 100644 imageprocess/src/model/ClassifyFNFRequest.cc create mode 100644 imageprocess/src/model/ClassifyFNFResult.cc create mode 100644 imageprocess/src/model/DetectHipKeypointXRayRequest.cc create mode 100644 imageprocess/src/model/DetectHipKeypointXRayResult.cc create mode 100644 imageprocess/src/model/DetectKneeKeypointXRayRequest.cc create mode 100644 imageprocess/src/model/DetectKneeKeypointXRayResult.cc create mode 100644 imageprocess/src/model/RunCTRegistrationRequest.cc create mode 100644 imageprocess/src/model/RunCTRegistrationResult.cc diff --git a/CHANGELOG b/CHANGELOG index 7e53aa44c..362f04159 100644 --- a/CHANGELOG +++ b/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. diff --git a/imageprocess/CMakeLists.txt b/imageprocess/CMakeLists.txt index e404b83e7..d0c64ef08 100644 --- a/imageprocess/CMakeLists.txt +++ b/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 ) diff --git a/imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h b/imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h index bb7e795cf..9b0ea8da2 100644 --- a/imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h +++ b/imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h @@ -22,8 +22,16 @@ #include #include #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 CalcCACSOutcome; + typedef std::future CalcCACSOutcomeCallable; + typedef std::function&)> CalcCACSAsyncHandler; + typedef Outcome ClassifyFNFOutcome; + typedef std::future ClassifyFNFOutcomeCallable; + typedef std::function&)> ClassifyFNFAsyncHandler; typedef Outcome DetectCovid19CadOutcome; typedef std::future DetectCovid19CadOutcomeCallable; typedef std::function&)> DetectCovid19CadAsyncHandler; + typedef Outcome DetectHipKeypointXRayOutcome; + typedef std::future DetectHipKeypointXRayOutcomeCallable; + typedef std::function&)> DetectHipKeypointXRayAsyncHandler; + typedef Outcome DetectKneeKeypointXRayOutcome; + typedef std::future DetectKneeKeypointXRayOutcomeCallable; + typedef std::function&)> DetectKneeKeypointXRayAsyncHandler; typedef Outcome DetectKneeXRayOutcome; typedef std::future DetectKneeXRayOutcomeCallable; typedef std::function&)> DetectKneeXRayAsyncHandler; @@ -58,6 +80,9 @@ namespace AlibabaCloud typedef Outcome GetAsyncJobResultOutcome; typedef std::future GetAsyncJobResultOutcomeCallable; typedef std::function&)> GetAsyncJobResultAsyncHandler; + typedef Outcome RunCTRegistrationOutcome; + typedef std::future RunCTRegistrationOutcomeCallable; + typedef std::function&)> RunCTRegistrationAsyncHandler; typedef Outcome TranslateMedOutcome; typedef std::future TranslateMedOutcomeCallable; typedef std::function&)> TranslateMedAsyncHandler; @@ -66,9 +91,21 @@ namespace AlibabaCloud ImageprocessClient(const std::shared_ptr &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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; TranslateMedOutcomeCallable translateMedCallable(const Model::TranslateMedRequest& request) const; diff --git a/imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h b/imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h new file mode 100644 index 000000000..c97ac0446 --- /dev/null +++ b/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 +#include +#include +#include + +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 getURLList()const; + void setURLList(const std::vector& 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_; + std::string orgId_; + bool async_; + std::string orgName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.h b/imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.h new file mode 100644 index 000000000..34809deab --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h b/imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h new file mode 100644 index 000000000..f63926158 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFResult.h b/imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFResult.h new file mode 100644 index 000000000..4861566bd --- /dev/null +++ b/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 +#include +#include +#include +#include + +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 boxes; + }; + std::string orgId; + std::vector 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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h b/imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h new file mode 100644 index 000000000..beda5e941 --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h b/imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h new file mode 100644 index 000000000..656b46545 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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 coordinates; + float value; + Tag tag; + }; + std::string orgId; + std::vector 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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h b/imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h new file mode 100644 index 000000000..5364869fd --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h b/imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h new file mode 100644 index 000000000..7e3699db4 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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 coordinates; + float value; + Tag tag; + }; + std::string orgId; + std::vector 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_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h b/imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h new file mode 100644 index 000000000..c9aee53ec --- /dev/null +++ b/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 +#include +#include +#include + +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 getReferenceList()const; + void setReferenceList(const std::vector& 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 getFloatingList()const; + void setFloatingList(const std::vector& floatingList); + + private: + std::string dataSourceType_; + std::string orgName_; + std::vector referenceList_; + std::string dataFormat_; + std::string orgId_; + bool async_; + std::vector floatingList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_ \ No newline at end of file diff --git a/imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h b/imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h new file mode 100644 index 000000000..8af509719 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageprocess/src/ImageprocessClient.cc b/imageprocess/src/ImageprocessClient.cc index c48872aa9..7bbb83ecf 100644 --- a/imageprocess/src/ImageprocessClient.cc +++ b/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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/imageprocess/src/model/CalcCACSRequest.cc b/imageprocess/src/model/CalcCACSRequest.cc new file mode 100644 index 000000000..cf1935429 --- /dev/null +++ b/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 + +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::getURLList()const +{ + return uRLList_; +} + +void CalcCACSRequest::setURLList(const std::vector& 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); +} + diff --git a/imageprocess/src/model/CalcCACSResult.cc b/imageprocess/src/model/CalcCACSResult.cc new file mode 100644 index 000000000..0a5c85483 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/imageprocess/src/model/ClassifyFNFRequest.cc b/imageprocess/src/model/ClassifyFNFRequest.cc new file mode 100644 index 000000000..2c3420e72 --- /dev/null +++ b/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 + +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); +} + diff --git a/imageprocess/src/model/ClassifyFNFResult.cc b/imageprocess/src/model/ClassifyFNFResult.cc new file mode 100644 index 000000000..20c8ad6f2 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/imageprocess/src/model/DetectHipKeypointXRayRequest.cc b/imageprocess/src/model/DetectHipKeypointXRayRequest.cc new file mode 100644 index 000000000..a5ef5b803 --- /dev/null +++ b/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 + +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); +} + diff --git a/imageprocess/src/model/DetectHipKeypointXRayResult.cc b/imageprocess/src/model/DetectHipKeypointXRayResult.cc new file mode 100644 index 000000000..e0155931e --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/imageprocess/src/model/DetectKneeKeypointXRayRequest.cc b/imageprocess/src/model/DetectKneeKeypointXRayRequest.cc new file mode 100644 index 000000000..da09fbdbf --- /dev/null +++ b/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 + +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); +} + diff --git a/imageprocess/src/model/DetectKneeKeypointXRayResult.cc b/imageprocess/src/model/DetectKneeKeypointXRayResult.cc new file mode 100644 index 000000000..66fe47ed8 --- /dev/null +++ b/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 +#include + +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_; +} + diff --git a/imageprocess/src/model/RunCTRegistrationRequest.cc b/imageprocess/src/model/RunCTRegistrationRequest.cc new file mode 100644 index 000000000..cea6afb21 --- /dev/null +++ b/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 + +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::getReferenceList()const +{ + return referenceList_; +} + +void RunCTRegistrationRequest::setReferenceList(const std::vector& 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::getFloatingList()const +{ + return floatingList_; +} + +void RunCTRegistrationRequest::setFloatingList(const std::vector& 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); + } +} + diff --git a/imageprocess/src/model/RunCTRegistrationResult.cc b/imageprocess/src/model/RunCTRegistrationResult.cc new file mode 100644 index 000000000..60a9c0b8f --- /dev/null +++ b/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 +#include + +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_; +} +