1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release DetectKneeKeypointXRay, DetectHipKeypointXRay, CalcCACS, RunCTRegistration, ClassifyFNF.

Browse Source
This commit is contained in:
sdk-team
2020-09-09 07:48:43 +00:00
parent 565bfada36
commit a3ccdb3f65
24 changed files with 1668 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -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.

20
imageprocess/CMakeLists.txt
View File

@@ -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 )

40
imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h
View File

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

68
imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSRequest : public RpcServiceRequest
{
public:
struct URLList
{
std::string uRL;
};
public:
CalcCACSRequest();
~CalcCACSRequest();
std::string getDataSourceType()const;
void setDataSourceType(const std::string& dataSourceType);
std::string getDataFormat()const;
void setDataFormat(const std::string& dataFormat);
std::vector<URLList> getURLList()const;
void setURLList(const std::vector<URLList>& uRLList);
std::string getOrgId()const;
void setOrgId(const std::string& orgId);
bool getAsync()const;
void setAsync(bool async);
std::string getOrgName()const;
void setOrgName(const std::string& orgName);
private:
std::string dataSourceType_;
std::string dataFormat_;
std::vector<URLList> uRLList_;
std::string orgId_;
bool async_;
std::string orgName_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_

55
imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSResult : public ServiceResult
{
public:
struct Data
{
std::string score;
};
CalcCACSResult();
explicit CalcCACSResult(const std::string &payload);
~CalcCACSResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSRESULT_H_

60
imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFRequest : public RpcServiceRequest
{
public:
ClassifyFNFRequest();
~ClassifyFNFRequest();
std::string getDataFormat()const;
void setDataFormat(const std::string& dataFormat);
std::string getOrgId()const;
void setOrgId(const std::string& orgId);
std::string getOrgName()const;
void setOrgName(const std::string& orgName);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
std::string getTracerId()const;
void setTracerId(const std::string& tracerId);
private:
std::string dataFormat_;
std::string orgId_;
std::string orgName_;
std::string imageUrl_;
std::string tracerId_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_

68
imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFResult : public ServiceResult
{
public:
struct Data
{
struct FracturesItem
{
struct Tag
{
std::string label;
};
float value;
Tag tag;
std::vector<std::string> boxes;
};
std::string orgId;
std::vector<FracturesItem> fractures;
std::string imageUrl;
std::string orgName;
};
ClassifyFNFResult();
explicit ClassifyFNFResult(const std::string &payload);
~ClassifyFNFResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFRESULT_H_

60
imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayRequest : public RpcServiceRequest
{
public:
DetectHipKeypointXRayRequest();
~DetectHipKeypointXRayRequest();
std::string getDataFormat()const;
void setDataFormat(const std::string& dataFormat);
std::string getOrgId()const;
void setOrgId(const std::string& orgId);
std::string getOrgName()const;
void setOrgName(const std::string& orgName);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
std::string getTracerId()const;
void setTracerId(const std::string& tracerId);
private:
std::string dataFormat_;
std::string orgId_;
std::string orgName_;
std::string imageUrl_;
std::string tracerId_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_

69
imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayResult : public ServiceResult
{
public:
struct Data
{
struct KeyPointsItem
{
struct Tag
{
std::string label;
std::string direction;
};
std::vector<std::string> coordinates;
float value;
Tag tag;
};
std::string orgId;
std::vector<KeyPointsItem> keyPoints;
std::string imageUrl;
std::string orgName;
};
DetectHipKeypointXRayResult();
explicit DetectHipKeypointXRayResult(const std::string &payload);
~DetectHipKeypointXRayResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYRESULT_H_

60
imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayRequest : public RpcServiceRequest
{
public:
DetectKneeKeypointXRayRequest();
~DetectKneeKeypointXRayRequest();
std::string getDataFormat()const;
void setDataFormat(const std::string& dataFormat);
std::string getOrgId()const;
void setOrgId(const std::string& orgId);
std::string getOrgName()const;
void setOrgName(const std::string& orgName);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
std::string getTracerId()const;
void setTracerId(const std::string& tracerId);
private:
std::string dataFormat_;
std::string orgId_;
std::string orgName_;
std::string imageUrl_;
std::string tracerId_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_

69
imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayResult : public ServiceResult
{
public:
struct Data
{
struct KeyPointsItem
{
struct Tag
{
std::string label;
std::string direction;
};
std::vector<std::string> coordinates;
float value;
Tag tag;
};
std::string orgId;
std::vector<KeyPointsItem> keyPoints;
std::string imageUrl;
std::string orgName;
};
DetectKneeKeypointXRayResult();
explicit DetectKneeKeypointXRayResult(const std::string &payload);
~DetectKneeKeypointXRayResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYRESULT_H_

75
imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationRequest : public RpcServiceRequest
{
public:
struct ReferenceList
{
std::string referenceURL;
};
struct FloatingList
{
std::string floatingURL;
};
public:
RunCTRegistrationRequest();
~RunCTRegistrationRequest();
std::string getDataSourceType()const;
void setDataSourceType(const std::string& dataSourceType);
std::string getOrgName()const;
void setOrgName(const std::string& orgName);
std::vector<ReferenceList> getReferenceList()const;
void setReferenceList(const std::vector<ReferenceList>& referenceList);
std::string getDataFormat()const;
void setDataFormat(const std::string& dataFormat);
std::string getOrgId()const;
void setOrgId(const std::string& orgId);
bool getAsync()const;
void setAsync(bool async);
std::vector<FloatingList> getFloatingList()const;
void setFloatingList(const std::vector<FloatingList>& floatingList);
private:
std::string dataSourceType_;
std::string orgName_;
std::vector<ReferenceList> referenceList_;
std::string dataFormat_;
std::string orgId_;
bool async_;
std::vector<FloatingList> floatingList_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_

56
imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h Normal file
View File

@@ -0,0 +1,56 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationResult : public ServiceResult
{
public:
struct Data
{
std::string nUrl;
std::string dUrl;
};
RunCTRegistrationResult();
explicit RunCTRegistrationResult(const std::string &payload);
~RunCTRegistrationResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONRESULT_H_

180
imageprocess/src/ImageprocessClient.cc
View File

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

99
imageprocess/src/model/CalcCACSRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/CalcCACSRequest.h>
using AlibabaCloud::Imageprocess::Model::CalcCACSRequest;
CalcCACSRequest::CalcCACSRequest() :
RpcServiceRequest("imageprocess", "2020-03-20", "CalcCACS")
{
setMethod(HttpRequest::Method::Post);
}
CalcCACSRequest::~CalcCACSRequest()
{}
std::string CalcCACSRequest::getDataSourceType()const
{
return dataSourceType_;
}
void CalcCACSRequest::setDataSourceType(const std::string& dataSourceType)
{
dataSourceType_ = dataSourceType;
setBodyParameter("DataSourceType", dataSourceType);
}
std::string CalcCACSRequest::getDataFormat()const
{
return dataFormat_;
}
void CalcCACSRequest::setDataFormat(const std::string& dataFormat)
{
dataFormat_ = dataFormat;
setBodyParameter("DataFormat", dataFormat);
}
std::vector<CalcCACSRequest::URLList> CalcCACSRequest::getURLList()const
{
return uRLList_;
}
void CalcCACSRequest::setURLList(const std::vector<URLList>& uRLList)
{
uRLList_ = uRLList;
for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
auto uRLListObj = uRLList.at(dep1);
std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
}
}
std::string CalcCACSRequest::getOrgId()const
{
return orgId_;
}
void CalcCACSRequest::setOrgId(const std::string& orgId)
{
orgId_ = orgId;
setBodyParameter("OrgId", orgId);
}
bool CalcCACSRequest::getAsync()const
{
return async_;
}
void CalcCACSRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string CalcCACSRequest::getOrgName()const
{
return orgName_;
}
void CalcCACSRequest::setOrgName(const std::string& orgName)
{
orgName_ = orgName;
setBodyParameter("OrgName", orgName);
}

52
imageprocess/src/model/CalcCACSResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/CalcCACSResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageprocess;
using namespace AlibabaCloud::Imageprocess::Model;
CalcCACSResult::CalcCACSResult() :
ServiceResult()
{}
CalcCACSResult::CalcCACSResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CalcCACSResult::~CalcCACSResult()
{}
void CalcCACSResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Score"].isNull())
data_.score = dataNode["Score"].asString();
}
CalcCACSResult::Data CalcCACSResult::getData()const
{
return data_;
}

84
imageprocess/src/model/ClassifyFNFRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/ClassifyFNFRequest.h>
using AlibabaCloud::Imageprocess::Model::ClassifyFNFRequest;
ClassifyFNFRequest::ClassifyFNFRequest() :
RpcServiceRequest("imageprocess", "2020-03-20", "ClassifyFNF")
{
setMethod(HttpRequest::Method::Post);
}
ClassifyFNFRequest::~ClassifyFNFRequest()
{}
std::string ClassifyFNFRequest::getDataFormat()const
{
return dataFormat_;
}
void ClassifyFNFRequest::setDataFormat(const std::string& dataFormat)
{
dataFormat_ = dataFormat;
setBodyParameter("DataFormat", dataFormat);
}
std::string ClassifyFNFRequest::getOrgId()const
{
return orgId_;
}
void ClassifyFNFRequest::setOrgId(const std::string& orgId)
{
orgId_ = orgId;
setBodyParameter("OrgId", orgId);
}
std::string ClassifyFNFRequest::getOrgName()const
{
return orgName_;
}
void ClassifyFNFRequest::setOrgName(const std::string& orgName)
{
orgName_ = orgName;
setBodyParameter("OrgName", orgName);
}
std::string ClassifyFNFRequest::getImageUrl()const
{
return imageUrl_;
}
void ClassifyFNFRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
std::string ClassifyFNFRequest::getTracerId()const
{
return tracerId_;
}
void ClassifyFNFRequest::setTracerId(const std::string& tracerId)
{
tracerId_ = tracerId;
setBodyParameter("TracerId", tracerId);
}

70
imageprocess/src/model/ClassifyFNFResult.cc Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/ClassifyFNFResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageprocess;
using namespace AlibabaCloud::Imageprocess::Model;
ClassifyFNFResult::ClassifyFNFResult() :
ServiceResult()
{}
ClassifyFNFResult::ClassifyFNFResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ClassifyFNFResult::~ClassifyFNFResult()
{}
void ClassifyFNFResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ImageUrl"].isNull())
data_.imageUrl = dataNode["ImageUrl"].asString();
if(!dataNode["OrgId"].isNull())
data_.orgId = dataNode["OrgId"].asString();
if(!dataNode["OrgName"].isNull())
data_.orgName = dataNode["OrgName"].asString();
auto allFracturesNode = dataNode["Fractures"]["FracturesItem"];
for (auto dataNodeFracturesFracturesItem : allFracturesNode)
{
Data::FracturesItem fracturesItemObject;
if(!dataNodeFracturesFracturesItem["Value"].isNull())
fracturesItemObject.value = std::stof(dataNodeFracturesFracturesItem["Value"].asString());
auto tagNode = value["Tag"];
if(!tagNode["Label"].isNull())
fracturesItemObject.tag.label = tagNode["Label"].asString();
auto allBoxes = value["Boxes"]["Boxes"];
for (auto value : allBoxes)
fracturesItemObject.boxes.push_back(value.asString());
data_.fractures.push_back(fracturesItemObject);
}
}
ClassifyFNFResult::Data ClassifyFNFResult::getData()const
{
return data_;
}

84
imageprocess/src/model/DetectHipKeypointXRayRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h>
using AlibabaCloud::Imageprocess::Model::DetectHipKeypointXRayRequest;
DetectHipKeypointXRayRequest::DetectHipKeypointXRayRequest() :
RpcServiceRequest("imageprocess", "2020-03-20", "DetectHipKeypointXRay")
{
setMethod(HttpRequest::Method::Post);
}
DetectHipKeypointXRayRequest::~DetectHipKeypointXRayRequest()
{}
std::string DetectHipKeypointXRayRequest::getDataFormat()const
{
return dataFormat_;
}
void DetectHipKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
{
dataFormat_ = dataFormat;
setBodyParameter("DataFormat", dataFormat);
}
std::string DetectHipKeypointXRayRequest::getOrgId()const
{
return orgId_;
}
void DetectHipKeypointXRayRequest::setOrgId(const std::string& orgId)
{
orgId_ = orgId;
setBodyParameter("OrgId", orgId);
}
std::string DetectHipKeypointXRayRequest::getOrgName()const
{
return orgName_;
}
void DetectHipKeypointXRayRequest::setOrgName(const std::string& orgName)
{
orgName_ = orgName;
setBodyParameter("OrgName", orgName);
}
std::string DetectHipKeypointXRayRequest::getImageUrl()const
{
return imageUrl_;
}
void DetectHipKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
std::string DetectHipKeypointXRayRequest::getTracerId()const
{
return tracerId_;
}
void DetectHipKeypointXRayRequest::setTracerId(const std::string& tracerId)
{
tracerId_ = tracerId;
setBodyParameter("TracerId", tracerId);
}

72
imageprocess/src/model/DetectHipKeypointXRayResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageprocess;
using namespace AlibabaCloud::Imageprocess::Model;
DetectHipKeypointXRayResult::DetectHipKeypointXRayResult() :
ServiceResult()
{}
DetectHipKeypointXRayResult::DetectHipKeypointXRayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectHipKeypointXRayResult::~DetectHipKeypointXRayResult()
{}
void DetectHipKeypointXRayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ImageUrl"].isNull())
data_.imageUrl = dataNode["ImageUrl"].asString();
if(!dataNode["OrgId"].isNull())
data_.orgId = dataNode["OrgId"].asString();
if(!dataNode["OrgName"].isNull())
data_.orgName = dataNode["OrgName"].asString();
auto allKeyPointsNode = dataNode["KeyPoints"]["KeyPointsItem"];
for (auto dataNodeKeyPointsKeyPointsItem : allKeyPointsNode)
{
Data::KeyPointsItem keyPointsItemObject;
if(!dataNodeKeyPointsKeyPointsItem["Value"].isNull())
keyPointsItemObject.value = std::stof(dataNodeKeyPointsKeyPointsItem["Value"].asString());
auto tagNode = value["Tag"];
if(!tagNode["Direction"].isNull())
keyPointsItemObject.tag.direction = tagNode["Direction"].asString();
if(!tagNode["Label"].isNull())
keyPointsItemObject.tag.label = tagNode["Label"].asString();
auto allCoordinates = value["Coordinates"]["Coordinate"];
for (auto value : allCoordinates)
keyPointsItemObject.coordinates.push_back(value.asString());
data_.keyPoints.push_back(keyPointsItemObject);
}
}
DetectHipKeypointXRayResult::Data DetectHipKeypointXRayResult::getData()const
{
return data_;
}

84
imageprocess/src/model/DetectKneeKeypointXRayRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h>
using AlibabaCloud::Imageprocess::Model::DetectKneeKeypointXRayRequest;
DetectKneeKeypointXRayRequest::DetectKneeKeypointXRayRequest() :
RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeKeypointXRay")
{
setMethod(HttpRequest::Method::Post);
}
DetectKneeKeypointXRayRequest::~DetectKneeKeypointXRayRequest()
{}
std::string DetectKneeKeypointXRayRequest::getDataFormat()const
{
return dataFormat_;
}
void DetectKneeKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
{
dataFormat_ = dataFormat;
setBodyParameter("DataFormat", dataFormat);
}
std::string DetectKneeKeypointXRayRequest::getOrgId()const
{
return orgId_;
}
void DetectKneeKeypointXRayRequest::setOrgId(const std::string& orgId)
{
orgId_ = orgId;
setBodyParameter("OrgId", orgId);
}
std::string DetectKneeKeypointXRayRequest::getOrgName()const
{
return orgName_;
}
void DetectKneeKeypointXRayRequest::setOrgName(const std::string& orgName)
{
orgName_ = orgName;
setBodyParameter("OrgName", orgName);
}
std::string DetectKneeKeypointXRayRequest::getImageUrl()const
{
return imageUrl_;
}
void DetectKneeKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
std::string DetectKneeKeypointXRayRequest::getTracerId()const
{
return tracerId_;
}
void DetectKneeKeypointXRayRequest::setTracerId(const std::string& tracerId)
{
tracerId_ = tracerId;
setBodyParameter("TracerId", tracerId);
}

72
imageprocess/src/model/DetectKneeKeypointXRayResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageprocess;
using namespace AlibabaCloud::Imageprocess::Model;
DetectKneeKeypointXRayResult::DetectKneeKeypointXRayResult() :
ServiceResult()
{}
DetectKneeKeypointXRayResult::DetectKneeKeypointXRayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DetectKneeKeypointXRayResult::~DetectKneeKeypointXRayResult()
{}
void DetectKneeKeypointXRayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ImageUrl"].isNull())
data_.imageUrl = dataNode["ImageUrl"].asString();
if(!dataNode["OrgId"].isNull())
data_.orgId = dataNode["OrgId"].asString();
if(!dataNode["OrgName"].isNull())
data_.orgName = dataNode["OrgName"].asString();
auto allKeyPointsNode = dataNode["KeyPoints"]["KeyPointsItem"];
for (auto dataNodeKeyPointsKeyPointsItem : allKeyPointsNode)
{
Data::KeyPointsItem keyPointsItemObject;
if(!dataNodeKeyPointsKeyPointsItem["Value"].isNull())
keyPointsItemObject.value = std::stof(dataNodeKeyPointsKeyPointsItem["Value"].asString());
auto tagNode = value["Tag"];
if(!tagNode["Direction"].isNull())
keyPointsItemObject.tag.direction = tagNode["Direction"].asString();
if(!tagNode["Label"].isNull())
keyPointsItemObject.tag.label = tagNode["Label"].asString();
auto allCoordinates = value["Coordinates"]["Coordinate"];
for (auto value : allCoordinates)
keyPointsItemObject.coordinates.push_back(value.asString());
data_.keyPoints.push_back(keyPointsItemObject);
}
}
DetectKneeKeypointXRayResult::Data DetectKneeKeypointXRayResult::getData()const
{
return data_;
}

114
imageprocess/src/model/RunCTRegistrationRequest.cc Normal file
View File

@@ -0,0 +1,114 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/RunCTRegistrationRequest.h>
using AlibabaCloud::Imageprocess::Model::RunCTRegistrationRequest;
RunCTRegistrationRequest::RunCTRegistrationRequest() :
RpcServiceRequest("imageprocess", "2020-03-20", "RunCTRegistration")
{
setMethod(HttpRequest::Method::Post);
}
RunCTRegistrationRequest::~RunCTRegistrationRequest()
{}
std::string RunCTRegistrationRequest::getDataSourceType()const
{
return dataSourceType_;
}
void RunCTRegistrationRequest::setDataSourceType(const std::string& dataSourceType)
{
dataSourceType_ = dataSourceType;
setBodyParameter("DataSourceType", dataSourceType);
}
std::string RunCTRegistrationRequest::getOrgName()const
{
return orgName_;
}
void RunCTRegistrationRequest::setOrgName(const std::string& orgName)
{
orgName_ = orgName;
setBodyParameter("OrgName", orgName);
}
std::vector<RunCTRegistrationRequest::ReferenceList> RunCTRegistrationRequest::getReferenceList()const
{
return referenceList_;
}
void RunCTRegistrationRequest::setReferenceList(const std::vector<ReferenceList>& referenceList)
{
referenceList_ = referenceList;
for(int dep1 = 0; dep1!= referenceList.size(); dep1++) {
auto referenceListObj = referenceList.at(dep1);
std::string referenceListObjStr = "ReferenceList." + std::to_string(dep1 + 1);
setParameter(referenceListObjStr + ".ReferenceURL", referenceListObj.referenceURL);
}
}
std::string RunCTRegistrationRequest::getDataFormat()const
{
return dataFormat_;
}
void RunCTRegistrationRequest::setDataFormat(const std::string& dataFormat)
{
dataFormat_ = dataFormat;
setBodyParameter("DataFormat", dataFormat);
}
std::string RunCTRegistrationRequest::getOrgId()const
{
return orgId_;
}
void RunCTRegistrationRequest::setOrgId(const std::string& orgId)
{
orgId_ = orgId;
setBodyParameter("OrgId", orgId);
}
bool RunCTRegistrationRequest::getAsync()const
{
return async_;
}
void RunCTRegistrationRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::vector<RunCTRegistrationRequest::FloatingList> RunCTRegistrationRequest::getFloatingList()const
{
return floatingList_;
}
void RunCTRegistrationRequest::setFloatingList(const std::vector<FloatingList>& floatingList)
{
floatingList_ = floatingList;
for(int dep1 = 0; dep1!= floatingList.size(); dep1++) {
auto floatingListObj = floatingList.at(dep1);
std::string floatingListObjStr = "FloatingList." + std::to_string(dep1 + 1);
setParameter(floatingListObjStr + ".FloatingURL", floatingListObj.floatingURL);
}
}

54
imageprocess/src/model/RunCTRegistrationResult.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageprocess/model/RunCTRegistrationResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageprocess;
using namespace AlibabaCloud::Imageprocess::Model;
RunCTRegistrationResult::RunCTRegistrationResult() :
ServiceResult()
{}
RunCTRegistrationResult::RunCTRegistrationResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RunCTRegistrationResult::~RunCTRegistrationResult()
{}
void RunCTRegistrationResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["DUrl"].isNull())
data_.dUrl = dataNode["DUrl"].asString();
if(!dataNode["NUrl"].isNull())
data_.nUrl = dataNode["NUrl"].asString();
}
RunCTRegistrationResult::Data RunCTRegistrationResult::getData()const
{
return data_;
}