Release GenerateDynamicImage.

This commit is contained in:
sdk-team
2020-10-13 02:45:13 +00:00
parent 134828d83c
commit 96b3defcc9
73 changed files with 4889 additions and 0 deletions

View File

@@ -0,0 +1,182 @@
/*
* 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_IMAGEENHAN_IMAGEENHANCLIENT_H_
#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ImageenhanExport.h"
#include "model/AssessCompositionRequest.h"
#include "model/AssessCompositionResult.h"
#include "model/AssessExposureRequest.h"
#include "model/AssessExposureResult.h"
#include "model/AssessSharpnessRequest.h"
#include "model/AssessSharpnessResult.h"
#include "model/ChangeImageSizeRequest.h"
#include "model/ChangeImageSizeResult.h"
#include "model/EnhanceImageColorRequest.h"
#include "model/EnhanceImageColorResult.h"
#include "model/ExtendImageStyleRequest.h"
#include "model/ExtendImageStyleResult.h"
#include "model/GenerateDynamicImageRequest.h"
#include "model/GenerateDynamicImageResult.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/ImageBlindCharacterWatermarkRequest.h"
#include "model/ImageBlindCharacterWatermarkResult.h"
#include "model/ImageBlindPicWatermarkRequest.h"
#include "model/ImageBlindPicWatermarkResult.h"
#include "model/ImitatePhotoStyleRequest.h"
#include "model/ImitatePhotoStyleResult.h"
#include "model/IntelligentCompositionRequest.h"
#include "model/IntelligentCompositionResult.h"
#include "model/MakeSuperResolutionImageRequest.h"
#include "model/MakeSuperResolutionImageResult.h"
#include "model/RecolorHDImageRequest.h"
#include "model/RecolorHDImageResult.h"
#include "model/RecolorImageRequest.h"
#include "model/RecolorImageResult.h"
#include "model/RemoveImageSubtitlesRequest.h"
#include "model/RemoveImageSubtitlesResult.h"
#include "model/RemoveImageWatermarkRequest.h"
#include "model/RemoveImageWatermarkResult.h"
namespace AlibabaCloud
{
namespace Imageenhan
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageenhanClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AssessCompositionResult> AssessCompositionOutcome;
typedef std::future<AssessCompositionOutcome> AssessCompositionOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessCompositionRequest&, const AssessCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessCompositionAsyncHandler;
typedef Outcome<Error, Model::AssessExposureResult> AssessExposureOutcome;
typedef std::future<AssessExposureOutcome> AssessExposureOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessExposureRequest&, const AssessExposureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessExposureAsyncHandler;
typedef Outcome<Error, Model::AssessSharpnessResult> AssessSharpnessOutcome;
typedef std::future<AssessSharpnessOutcome> AssessSharpnessOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::AssessSharpnessRequest&, const AssessSharpnessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessSharpnessAsyncHandler;
typedef Outcome<Error, Model::ChangeImageSizeResult> ChangeImageSizeOutcome;
typedef std::future<ChangeImageSizeOutcome> ChangeImageSizeOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ChangeImageSizeRequest&, const ChangeImageSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeImageSizeAsyncHandler;
typedef Outcome<Error, Model::EnhanceImageColorResult> EnhanceImageColorOutcome;
typedef std::future<EnhanceImageColorOutcome> EnhanceImageColorOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::EnhanceImageColorRequest&, const EnhanceImageColorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceImageColorAsyncHandler;
typedef Outcome<Error, Model::ExtendImageStyleResult> ExtendImageStyleOutcome;
typedef std::future<ExtendImageStyleOutcome> ExtendImageStyleOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ExtendImageStyleRequest&, const ExtendImageStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtendImageStyleAsyncHandler;
typedef Outcome<Error, Model::GenerateDynamicImageResult> GenerateDynamicImageOutcome;
typedef std::future<GenerateDynamicImageOutcome> GenerateDynamicImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::GenerateDynamicImageRequest&, const GenerateDynamicImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDynamicImageAsyncHandler;
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::ImageBlindCharacterWatermarkResult> ImageBlindCharacterWatermarkOutcome;
typedef std::future<ImageBlindCharacterWatermarkOutcome> ImageBlindCharacterWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindCharacterWatermarkRequest&, const ImageBlindCharacterWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindCharacterWatermarkAsyncHandler;
typedef Outcome<Error, Model::ImageBlindPicWatermarkResult> ImageBlindPicWatermarkOutcome;
typedef std::future<ImageBlindPicWatermarkOutcome> ImageBlindPicWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindPicWatermarkRequest&, const ImageBlindPicWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindPicWatermarkAsyncHandler;
typedef Outcome<Error, Model::ImitatePhotoStyleResult> ImitatePhotoStyleOutcome;
typedef std::future<ImitatePhotoStyleOutcome> ImitatePhotoStyleOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::ImitatePhotoStyleRequest&, const ImitatePhotoStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImitatePhotoStyleAsyncHandler;
typedef Outcome<Error, Model::IntelligentCompositionResult> IntelligentCompositionOutcome;
typedef std::future<IntelligentCompositionOutcome> IntelligentCompositionOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::IntelligentCompositionRequest&, const IntelligentCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IntelligentCompositionAsyncHandler;
typedef Outcome<Error, Model::MakeSuperResolutionImageResult> MakeSuperResolutionImageOutcome;
typedef std::future<MakeSuperResolutionImageOutcome> MakeSuperResolutionImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::MakeSuperResolutionImageRequest&, const MakeSuperResolutionImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MakeSuperResolutionImageAsyncHandler;
typedef Outcome<Error, Model::RecolorHDImageResult> RecolorHDImageOutcome;
typedef std::future<RecolorHDImageOutcome> RecolorHDImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RecolorHDImageRequest&, const RecolorHDImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorHDImageAsyncHandler;
typedef Outcome<Error, Model::RecolorImageResult> RecolorImageOutcome;
typedef std::future<RecolorImageOutcome> RecolorImageOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RecolorImageRequest&, const RecolorImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorImageAsyncHandler;
typedef Outcome<Error, Model::RemoveImageSubtitlesResult> RemoveImageSubtitlesOutcome;
typedef std::future<RemoveImageSubtitlesOutcome> RemoveImageSubtitlesOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageSubtitlesRequest&, const RemoveImageSubtitlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageSubtitlesAsyncHandler;
typedef Outcome<Error, Model::RemoveImageWatermarkResult> RemoveImageWatermarkOutcome;
typedef std::future<RemoveImageWatermarkOutcome> RemoveImageWatermarkOutcomeCallable;
typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageWatermarkRequest&, const RemoveImageWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageWatermarkAsyncHandler;
ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration);
ImageenhanClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ImageenhanClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ImageenhanClient();
AssessCompositionOutcome assessComposition(const Model::AssessCompositionRequest &request)const;
void assessCompositionAsync(const Model::AssessCompositionRequest& request, const AssessCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessCompositionOutcomeCallable assessCompositionCallable(const Model::AssessCompositionRequest& request) const;
AssessExposureOutcome assessExposure(const Model::AssessExposureRequest &request)const;
void assessExposureAsync(const Model::AssessExposureRequest& request, const AssessExposureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessExposureOutcomeCallable assessExposureCallable(const Model::AssessExposureRequest& request) const;
AssessSharpnessOutcome assessSharpness(const Model::AssessSharpnessRequest &request)const;
void assessSharpnessAsync(const Model::AssessSharpnessRequest& request, const AssessSharpnessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssessSharpnessOutcomeCallable assessSharpnessCallable(const Model::AssessSharpnessRequest& request) const;
ChangeImageSizeOutcome changeImageSize(const Model::ChangeImageSizeRequest &request)const;
void changeImageSizeAsync(const Model::ChangeImageSizeRequest& request, const ChangeImageSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeImageSizeOutcomeCallable changeImageSizeCallable(const Model::ChangeImageSizeRequest& request) const;
EnhanceImageColorOutcome enhanceImageColor(const Model::EnhanceImageColorRequest &request)const;
void enhanceImageColorAsync(const Model::EnhanceImageColorRequest& request, const EnhanceImageColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnhanceImageColorOutcomeCallable enhanceImageColorCallable(const Model::EnhanceImageColorRequest& request) const;
ExtendImageStyleOutcome extendImageStyle(const Model::ExtendImageStyleRequest &request)const;
void extendImageStyleAsync(const Model::ExtendImageStyleRequest& request, const ExtendImageStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtendImageStyleOutcomeCallable extendImageStyleCallable(const Model::ExtendImageStyleRequest& request) const;
GenerateDynamicImageOutcome generateDynamicImage(const Model::GenerateDynamicImageRequest &request)const;
void generateDynamicImageAsync(const Model::GenerateDynamicImageRequest& request, const GenerateDynamicImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateDynamicImageOutcomeCallable generateDynamicImageCallable(const Model::GenerateDynamicImageRequest& request) const;
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;
ImageBlindCharacterWatermarkOutcome imageBlindCharacterWatermark(const Model::ImageBlindCharacterWatermarkRequest &request)const;
void imageBlindCharacterWatermarkAsync(const Model::ImageBlindCharacterWatermarkRequest& request, const ImageBlindCharacterWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageBlindCharacterWatermarkOutcomeCallable imageBlindCharacterWatermarkCallable(const Model::ImageBlindCharacterWatermarkRequest& request) const;
ImageBlindPicWatermarkOutcome imageBlindPicWatermark(const Model::ImageBlindPicWatermarkRequest &request)const;
void imageBlindPicWatermarkAsync(const Model::ImageBlindPicWatermarkRequest& request, const ImageBlindPicWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageBlindPicWatermarkOutcomeCallable imageBlindPicWatermarkCallable(const Model::ImageBlindPicWatermarkRequest& request) const;
ImitatePhotoStyleOutcome imitatePhotoStyle(const Model::ImitatePhotoStyleRequest &request)const;
void imitatePhotoStyleAsync(const Model::ImitatePhotoStyleRequest& request, const ImitatePhotoStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImitatePhotoStyleOutcomeCallable imitatePhotoStyleCallable(const Model::ImitatePhotoStyleRequest& request) const;
IntelligentCompositionOutcome intelligentComposition(const Model::IntelligentCompositionRequest &request)const;
void intelligentCompositionAsync(const Model::IntelligentCompositionRequest& request, const IntelligentCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
IntelligentCompositionOutcomeCallable intelligentCompositionCallable(const Model::IntelligentCompositionRequest& request) const;
MakeSuperResolutionImageOutcome makeSuperResolutionImage(const Model::MakeSuperResolutionImageRequest &request)const;
void makeSuperResolutionImageAsync(const Model::MakeSuperResolutionImageRequest& request, const MakeSuperResolutionImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MakeSuperResolutionImageOutcomeCallable makeSuperResolutionImageCallable(const Model::MakeSuperResolutionImageRequest& request) const;
RecolorHDImageOutcome recolorHDImage(const Model::RecolorHDImageRequest &request)const;
void recolorHDImageAsync(const Model::RecolorHDImageRequest& request, const RecolorHDImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecolorHDImageOutcomeCallable recolorHDImageCallable(const Model::RecolorHDImageRequest& request) const;
RecolorImageOutcome recolorImage(const Model::RecolorImageRequest &request)const;
void recolorImageAsync(const Model::RecolorImageRequest& request, const RecolorImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecolorImageOutcomeCallable recolorImageCallable(const Model::RecolorImageRequest& request) const;
RemoveImageSubtitlesOutcome removeImageSubtitles(const Model::RemoveImageSubtitlesRequest &request)const;
void removeImageSubtitlesAsync(const Model::RemoveImageSubtitlesRequest& request, const RemoveImageSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveImageSubtitlesOutcomeCallable removeImageSubtitlesCallable(const Model::RemoveImageSubtitlesRequest& request) const;
RemoveImageWatermarkOutcome removeImageWatermark(const Model::RemoveImageWatermarkRequest &request)const;
void removeImageWatermarkAsync(const Model::RemoveImageWatermarkRequest& request, const RemoveImageWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveImageWatermarkOutcomeCallable removeImageWatermarkCallable(const Model::RemoveImageWatermarkRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* 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_IMAGEENHAN_IMAGEENHANEXPORT_H_
#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_IMAGEENHAN_LIBRARY)
# define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_IMAGEENHAN_EXPORT
#endif
#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_

View File

@@ -0,0 +1,48 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionRequest : public RpcServiceRequest
{
public:
AssessCompositionRequest();
~AssessCompositionRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_

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_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionResult : public ServiceResult
{
public:
struct Data
{
float score;
};
AssessCompositionResult();
explicit AssessCompositionResult(const std::string &payload);
~AssessCompositionResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureRequest : public RpcServiceRequest
{
public:
AssessExposureRequest();
~AssessExposureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_

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_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureResult : public ServiceResult
{
public:
struct Data
{
float exposure;
};
AssessExposureResult();
explicit AssessExposureResult(const std::string &payload);
~AssessExposureResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessRequest : public RpcServiceRequest
{
public:
AssessSharpnessRequest();
~AssessSharpnessRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_

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_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessResult : public ServiceResult
{
public:
struct Data
{
float sharpness;
};
AssessSharpnessResult();
explicit AssessSharpnessResult(const std::string &payload);
~AssessSharpnessResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_

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.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeRequest : public RpcServiceRequest
{
public:
ChangeImageSizeRequest();
~ChangeImageSizeRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
int getWidth()const;
void setWidth(int width);
int getHeight()const;
void setHeight(int height);
private:
std::string url_;
int width_;
int height_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeResult : public ServiceResult
{
public:
struct Data
{
struct RetainLocation
{
int x;
int y;
int height;
int width;
};
RetainLocation retainLocation;
std::string url;
};
ChangeImageSizeResult();
explicit ChangeImageSizeResult(const std::string &payload);
~ChangeImageSizeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZERESULT_H_

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.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorRequest : public RpcServiceRequest
{
public:
EnhanceImageColorRequest();
~EnhanceImageColorRequest();
std::string getMode()const;
void setMode(const std::string& mode);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
private:
std::string mode_;
std::string imageURL_;
std::string outputFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_

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_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
EnhanceImageColorResult();
explicit EnhanceImageColorResult(const std::string &payload);
~EnhanceImageColorResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleRequest : public RpcServiceRequest
{
public:
ExtendImageStyleRequest();
~ExtendImageStyleRequest();
std::string getMajorUrl()const;
void setMajorUrl(const std::string& majorUrl);
std::string getStyleUrl()const;
void setStyleUrl(const std::string& styleUrl);
private:
std::string majorUrl_;
std::string styleUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_

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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleResult : public ServiceResult
{
public:
struct Data
{
std::string url;
std::string majorUrl;
};
ExtendImageStyleResult();
explicit ExtendImageStyleResult(const std::string &payload);
~ExtendImageStyleResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageRequest : public RpcServiceRequest
{
public:
GenerateDynamicImageRequest();
~GenerateDynamicImageRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getOperation()const;
void setOperation(const std::string& operation);
private:
std::string url_;
std::string operation_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_

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_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageResult : public ServiceResult
{
public:
struct Data
{
std::string url;
};
GenerateDynamicImageResult();
explicit GenerateDynamicImageResult(const std::string &payload);
~GenerateDynamicImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
bool async_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_

View File

@@ -0,0 +1,59 @@
/*
* 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_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultResult : public ServiceResult
{
public:
struct Data
{
std::string status;
std::string errorCode;
std::string errorMessage;
std::string jobId;
std::string result;
};
GetAsyncJobResultResult();
explicit GetAsyncJobResultResult(const std::string &payload);
~GetAsyncJobResultResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkRequest : public RpcServiceRequest
{
public:
ImageBlindCharacterWatermarkRequest();
~ImageBlindCharacterWatermarkRequest();
std::string getWatermarkImageURL()const;
void setWatermarkImageURL(const std::string& watermarkImageURL);
int getQualityFactor()const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType()const;
void setFunctionType(const std::string& functionType);
std::string getOutputFileType()const;
void setOutputFileType(const std::string& outputFileType);
std::string getOriginImageURL()const;
void setOriginImageURL(const std::string& originImageURL);
std::string getText()const;
void setText(const std::string& text);
private:
std::string watermarkImageURL_;
int qualityFactor_;
std::string functionType_;
std::string outputFileType_;
std::string originImageURL_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_

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_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkResult : public ServiceResult
{
public:
struct Data
{
std::string textImageURL;
std::string watermarkImageURL;
};
ImageBlindCharacterWatermarkResult();
explicit ImageBlindCharacterWatermarkResult(const std::string &payload);
~ImageBlindCharacterWatermarkResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkRequest : public RpcServiceRequest
{
public:
ImageBlindPicWatermarkRequest();
~ImageBlindPicWatermarkRequest();
std::string getWatermarkImageURL()const;
void setWatermarkImageURL(const std::string& watermarkImageURL);
int getQualityFactor()const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType()const;
void setFunctionType(const std::string& functionType);
std::string getLogoURL()const;
void setLogoURL(const std::string& logoURL);
std::string getOutputFileType()const;
void setOutputFileType(const std::string& outputFileType);
std::string getOriginImageURL()const;
void setOriginImageURL(const std::string& originImageURL);
private:
std::string watermarkImageURL_;
int qualityFactor_;
std::string functionType_;
std::string logoURL_;
std::string outputFileType_;
std::string originImageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_

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_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkResult : public ServiceResult
{
public:
struct Data
{
std::string watermarkImageURL;
std::string logoURL;
};
ImageBlindPicWatermarkResult();
explicit ImageBlindPicWatermarkResult(const std::string &payload);
~ImageBlindPicWatermarkResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleRequest : public RpcServiceRequest
{
public:
ImitatePhotoStyleRequest();
~ImitatePhotoStyleRequest();
std::string getStyleUrl()const;
void setStyleUrl(const std::string& styleUrl);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string styleUrl_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_

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_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
ImitatePhotoStyleResult();
explicit ImitatePhotoStyleResult(const std::string &payload);
~ImitatePhotoStyleResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT IntelligentCompositionRequest : public RpcServiceRequest
{
public:
IntelligentCompositionRequest();
~IntelligentCompositionRequest();
int getNumBoxes()const;
void setNumBoxes(int numBoxes);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int numBoxes_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_

View File

@@ -0,0 +1,63 @@
/*
* 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_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT IntelligentCompositionResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
int maxX;
int maxY;
int minX;
float score;
int minY;
};
std::vector<Element> elements;
};
IntelligentCompositionResult();
explicit IntelligentCompositionResult(const std::string &payload);
~IntelligentCompositionResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONRESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* 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_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT MakeSuperResolutionImageRequest : public RpcServiceRequest
{
public:
MakeSuperResolutionImageRequest();
~MakeSuperResolutionImageRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
private:
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_

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_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT MakeSuperResolutionImageResult : public ServiceResult
{
public:
struct Data
{
std::string url;
};
MakeSuperResolutionImageResult();
explicit MakeSuperResolutionImageResult(const std::string &payload);
~MakeSuperResolutionImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_

View File

@@ -0,0 +1,71 @@
/*
* 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_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageRequest : public RpcServiceRequest
{
public:
struct ColorTemplate
{
std::string color;
};
public:
RecolorHDImageRequest();
~RecolorHDImageRequest();
std::vector<ColorTemplate> getColorTemplate()const;
void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
std::string getDegree()const;
void setDegree(const std::string& degree);
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getMode()const;
void setMode(const std::string& mode);
bool getAsync()const;
void setAsync(bool async);
int getColorCount()const;
void setColorCount(int colorCount);
std::string getRefUrl()const;
void setRefUrl(const std::string& refUrl);
private:
std::vector<ColorTemplate> colorTemplate_;
std::string degree_;
std::string url_;
std::string mode_;
bool async_;
int colorCount_;
std::string refUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_

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_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> imageList;
};
RecolorHDImageResult();
explicit RecolorHDImageResult(const std::string &payload);
~RecolorHDImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_

View File

@@ -0,0 +1,65 @@
/*
* 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_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageRequest : public RpcServiceRequest
{
public:
struct ColorTemplate
{
std::string color;
};
public:
RecolorImageRequest();
~RecolorImageRequest();
std::vector<ColorTemplate> getColorTemplate()const;
void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getMode()const;
void setMode(const std::string& mode);
int getColorCount()const;
void setColorCount(int colorCount);
std::string getRefUrl()const;
void setRefUrl(const std::string& refUrl);
private:
std::vector<ColorTemplate> colorTemplate_;
std::string url_;
std::string mode_;
int colorCount_;
std::string refUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_

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_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> imageList;
};
RecolorImageResult();
explicit RecolorImageResult(const std::string &payload);
~RecolorImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_

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_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesRequest : public RpcServiceRequest
{
public:
RemoveImageSubtitlesRequest();
~RemoveImageSubtitlesRequest();
float getBH()const;
void setBH(float bH);
float getBW()const;
void setBW(float bW);
float getBX()const;
void setBX(float bX);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
float getBY()const;
void setBY(float bY);
private:
float bH_;
float bW_;
float bX_;
std::string imageURL_;
float bY_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_

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_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
RemoveImageSubtitlesResult();
explicit RemoveImageSubtitlesResult(const std::string &payload);
~RemoveImageSubtitlesResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* 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_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageWatermarkRequest : public RpcServiceRequest
{
public:
RemoveImageWatermarkRequest();
~RemoveImageWatermarkRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_

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_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageWatermarkResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
RemoveImageWatermarkResult();
explicit RemoveImageWatermarkResult(const std::string &payload);
~RemoveImageWatermarkResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_