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

Release ScreenGC.

Browse Source
This commit is contained in:
sdk-team
2023-05-31 02:28:08 +00:00
parent 5e1ff681ee
commit 38f1feda73
24 changed files with 1835 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

83
imageprocess/include/alibabacloud/imageprocess/model/DetectLiverSteatosisResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectLiverSteatosisResult : public ServiceResult
{
public:
struct Data
{
struct DetectionsItem
{
long radius;
float liverSpleenDifference;
float liverSlice;
float liverHU;
std::string prediction;
float probability;
float spleenHU;
std::vector<std::string> spleenCenter;
float liverSpleenRatio;
float spleenVolume;
std::vector<std::string> rOI2Center;
std::vector<std::string> rOI3Center;
float spleenSlice;
float liverROI1;
std::vector<std::string> rOI1Center;
float liverVolume;
float spleenROI;
float liverROI2;
float liverROI3;
};
std::vector<std::string> origin;
std::vector<std::string> spacing;
std::vector<DetectionsItem> detections;
};
DetectLiverSteatosisResult();
explicit DetectLiverSteatosisResult(const std::string &payload);
~DetectLiverSteatosisResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLIVERSTEATOSISRESULT_H_

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

82
imageprocess/include/alibabacloud/imageprocess/model/PredictCVDResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT PredictCVDResult : public ServiceResult
{
public:
struct Data
{
struct Lesion
{
struct FeatureScore
{
std::vector<std::string> eatHUSTD;
std::vector<std::string> coronaryCalciumScore;
std::vector<std::string> rightLungLowattRatio;
std::vector<std::string> ascendAortaLength;
std::vector<std::string> myoEpiRatio;
std::vector<std::string> eatHUMean;
std::vector<std::string> leftLungLowattRatio;
std::vector<std::string> ascAoMaxDiam;
std::vector<std::string> eatVolume;
std::vector<std::string> coronaryCalciumVol;
std::vector<std::string> cardioThoracicRatio;
std::vector<std::string> deepFeature;
std::vector<std::string> aortaCalciumScore;
std::vector<std::string> aortaCalciumVolume;
};
FeatureScore featureScore;
float cVDProbability;
std::vector<std::string> resultURL;
};
Lesion lesion;
};
PredictCVDResult();
explicit PredictCVDResult(const std::string &payload);
~PredictCVDResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_PREDICTCVDRESULT_H_

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

68
imageprocess/include/alibabacloud/imageprocess/model/ScreenCRCResult.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_SCREENCRCRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCRCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenCRCResult : public ServiceResult
{
public:
struct Data
{
struct Lesion
{
std::string cRCVolume;
std::string colorectumVolume;
std::string mask;
std::string stage2Volume;
std::string probabilities;
std::string nonCRCVolumel;
};
Lesion lesion;
};
ScreenCRCResult();
explicit ScreenCRCResult(const std::string &payload);
~ScreenCRCResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCRCRESULT_H_

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

68
imageprocess/include/alibabacloud/imageprocess/model/ScreenGCResult.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_SCREENGCRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENGCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenGCResult : public ServiceResult
{
public:
struct Data
{
struct Lesion
{
std::string nonGCVolume;
std::string stomachVolume;
std::string gCVolume;
std::string mask;
std::string stage2Volume;
std::string probabilities;
};
Lesion lesion;
};
ScreenGCResult();
explicit ScreenGCResult(const std::string &payload);
~ScreenGCResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENGCRESULT_H_

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

83
imageprocess/include/alibabacloud/imageprocess/model/ScreenLCResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCRESULT_H_
#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageprocess/ImageprocessExport.h>
namespace AlibabaCloud
{
namespace Imageprocess
{
namespace Model
{
class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenLCResult : public ServiceResult
{
public:
struct Data
{
struct Lesion
{
struct PatientLevelResult
{
float malignantNonHCCProb;
float hCCProb;
float tumorNonCystProb;
float cystProb;
std::string benignNonCystProb;
};
struct LesionListItem
{
std::string type;
float volume;
std::vector<std::string> recistEndpoints;
float malignancy;
std::vector<std::string> diameter;
long keySlice;
};
std::vector<LesionListItem> lesionList;
PatientLevelResult patientLevelResult;
std::string mask;
float liverVolume;
};
Lesion lesion;
};
ScreenLCResult();
explicit ScreenLCResult(const std::string &payload);
~ScreenLCResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENLCRESULT_H_