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

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_