From 96b3defcc958dbd11518e439d3b9527088448bd3 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 13 Oct 2020 02:45:13 +0000 Subject: [PATCH] Release GenerateDynamicImage. --- CHANGELOG | 3 + imageenhan/CMakeLists.txt | 150 ++++ .../imageenhan/ImageenhanClient.h | 182 +++++ .../imageenhan/ImageenhanExport.h | 32 + .../model/AssessCompositionRequest.h | 48 ++ .../model/AssessCompositionResult.h | 55 ++ .../imageenhan/model/AssessExposureRequest.h | 48 ++ .../imageenhan/model/AssessExposureResult.h | 55 ++ .../imageenhan/model/AssessSharpnessRequest.h | 48 ++ .../imageenhan/model/AssessSharpnessResult.h | 55 ++ .../imageenhan/model/ChangeImageSizeRequest.h | 54 ++ .../imageenhan/model/ChangeImageSizeResult.h | 63 ++ .../model/EnhanceImageColorRequest.h | 54 ++ .../model/EnhanceImageColorResult.h | 55 ++ .../model/ExtendImageStyleRequest.h | 51 ++ .../imageenhan/model/ExtendImageStyleResult.h | 56 ++ .../model/GenerateDynamicImageRequest.h | 51 ++ .../model/GenerateDynamicImageResult.h | 55 ++ .../model/GetAsyncJobResultRequest.h | 51 ++ .../model/GetAsyncJobResultResult.h | 59 ++ .../ImageBlindCharacterWatermarkRequest.h | 63 ++ .../ImageBlindCharacterWatermarkResult.h | 56 ++ .../model/ImageBlindPicWatermarkRequest.h | 63 ++ .../model/ImageBlindPicWatermarkResult.h | 56 ++ .../model/ImitatePhotoStyleRequest.h | 51 ++ .../model/ImitatePhotoStyleResult.h | 55 ++ .../model/IntelligentCompositionRequest.h | 51 ++ .../model/IntelligentCompositionResult.h | 63 ++ .../model/MakeSuperResolutionImageRequest.h | 48 ++ .../model/MakeSuperResolutionImageResult.h | 55 ++ .../imageenhan/model/RecolorHDImageRequest.h | 71 ++ .../imageenhan/model/RecolorHDImageResult.h | 55 ++ .../imageenhan/model/RecolorImageRequest.h | 65 ++ .../imageenhan/model/RecolorImageResult.h | 55 ++ .../model/RemoveImageSubtitlesRequest.h | 60 ++ .../model/RemoveImageSubtitlesResult.h | 55 ++ .../model/RemoveImageWatermarkRequest.h | 48 ++ .../model/RemoveImageWatermarkResult.h | 55 ++ imageenhan/src/ImageenhanClient.cc | 665 ++++++++++++++++++ .../src/model/AssessCompositionRequest.cc | 40 ++ .../src/model/AssessCompositionResult.cc | 52 ++ imageenhan/src/model/AssessExposureRequest.cc | 40 ++ imageenhan/src/model/AssessExposureResult.cc | 52 ++ .../src/model/AssessSharpnessRequest.cc | 40 ++ imageenhan/src/model/AssessSharpnessResult.cc | 52 ++ .../src/model/ChangeImageSizeRequest.cc | 62 ++ imageenhan/src/model/ChangeImageSizeResult.cc | 61 ++ .../src/model/EnhanceImageColorRequest.cc | 62 ++ .../src/model/EnhanceImageColorResult.cc | 52 ++ .../src/model/ExtendImageStyleRequest.cc | 51 ++ .../src/model/ExtendImageStyleResult.cc | 54 ++ .../src/model/GenerateDynamicImageRequest.cc | 51 ++ .../src/model/GenerateDynamicImageResult.cc | 52 ++ .../src/model/GetAsyncJobResultRequest.cc | 51 ++ .../src/model/GetAsyncJobResultResult.cc | 60 ++ .../ImageBlindCharacterWatermarkRequest.cc | 95 +++ .../ImageBlindCharacterWatermarkResult.cc | 54 ++ .../model/ImageBlindPicWatermarkRequest.cc | 95 +++ .../src/model/ImageBlindPicWatermarkResult.cc | 54 ++ .../src/model/ImitatePhotoStyleRequest.cc | 51 ++ .../src/model/ImitatePhotoStyleResult.cc | 52 ++ .../model/IntelligentCompositionRequest.cc | 51 ++ .../src/model/IntelligentCompositionResult.cc | 66 ++ .../model/MakeSuperResolutionImageRequest.cc | 40 ++ .../model/MakeSuperResolutionImageResult.cc | 52 ++ imageenhan/src/model/RecolorHDImageRequest.cc | 110 +++ imageenhan/src/model/RecolorHDImageResult.cc | 53 ++ imageenhan/src/model/RecolorImageRequest.cc | 88 +++ imageenhan/src/model/RecolorImageResult.cc | 53 ++ .../src/model/RemoveImageSubtitlesRequest.cc | 84 +++ .../src/model/RemoveImageSubtitlesResult.cc | 52 ++ .../src/model/RemoveImageWatermarkRequest.cc | 40 ++ .../src/model/RemoveImageWatermarkResult.cc | 52 ++ 73 files changed, 4889 insertions(+) create mode 100644 imageenhan/CMakeLists.txt create mode 100644 imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RecolorImageResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h create mode 100644 imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h create mode 100644 imageenhan/src/ImageenhanClient.cc create mode 100644 imageenhan/src/model/AssessCompositionRequest.cc create mode 100644 imageenhan/src/model/AssessCompositionResult.cc create mode 100644 imageenhan/src/model/AssessExposureRequest.cc create mode 100644 imageenhan/src/model/AssessExposureResult.cc create mode 100644 imageenhan/src/model/AssessSharpnessRequest.cc create mode 100644 imageenhan/src/model/AssessSharpnessResult.cc create mode 100644 imageenhan/src/model/ChangeImageSizeRequest.cc create mode 100644 imageenhan/src/model/ChangeImageSizeResult.cc create mode 100644 imageenhan/src/model/EnhanceImageColorRequest.cc create mode 100644 imageenhan/src/model/EnhanceImageColorResult.cc create mode 100644 imageenhan/src/model/ExtendImageStyleRequest.cc create mode 100644 imageenhan/src/model/ExtendImageStyleResult.cc create mode 100644 imageenhan/src/model/GenerateDynamicImageRequest.cc create mode 100644 imageenhan/src/model/GenerateDynamicImageResult.cc create mode 100644 imageenhan/src/model/GetAsyncJobResultRequest.cc create mode 100644 imageenhan/src/model/GetAsyncJobResultResult.cc create mode 100644 imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc create mode 100644 imageenhan/src/model/ImageBlindCharacterWatermarkResult.cc create mode 100644 imageenhan/src/model/ImageBlindPicWatermarkRequest.cc create mode 100644 imageenhan/src/model/ImageBlindPicWatermarkResult.cc create mode 100644 imageenhan/src/model/ImitatePhotoStyleRequest.cc create mode 100644 imageenhan/src/model/ImitatePhotoStyleResult.cc create mode 100644 imageenhan/src/model/IntelligentCompositionRequest.cc create mode 100644 imageenhan/src/model/IntelligentCompositionResult.cc create mode 100644 imageenhan/src/model/MakeSuperResolutionImageRequest.cc create mode 100644 imageenhan/src/model/MakeSuperResolutionImageResult.cc create mode 100644 imageenhan/src/model/RecolorHDImageRequest.cc create mode 100644 imageenhan/src/model/RecolorHDImageResult.cc create mode 100644 imageenhan/src/model/RecolorImageRequest.cc create mode 100644 imageenhan/src/model/RecolorImageResult.cc create mode 100644 imageenhan/src/model/RemoveImageSubtitlesRequest.cc create mode 100644 imageenhan/src/model/RemoveImageSubtitlesResult.cc create mode 100644 imageenhan/src/model/RemoveImageWatermarkRequest.cc create mode 100644 imageenhan/src/model/RemoveImageWatermarkResult.cc diff --git a/CHANGELOG b/CHANGELOG index 46a4fe89c..2953d79c6 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-10-13 Version: patch +- Release GenerateDynamicImage. + 2020-10-13 Version: patch - Generated 2019-01-01 for `Cassandra`. diff --git a/imageenhan/CMakeLists.txt b/imageenhan/CMakeLists.txt new file mode 100644 index 000000000..01e6d19c6 --- /dev/null +++ b/imageenhan/CMakeLists.txt @@ -0,0 +1,150 @@ +# +# 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. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(imageenhan_public_header + include/alibabacloud/imageenhan/ImageenhanClient.h + include/alibabacloud/imageenhan/ImageenhanExport.h ) + +set(imageenhan_public_header_model + include/alibabacloud/imageenhan/model/AssessCompositionRequest.h + include/alibabacloud/imageenhan/model/AssessCompositionResult.h + include/alibabacloud/imageenhan/model/AssessExposureRequest.h + include/alibabacloud/imageenhan/model/AssessExposureResult.h + include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h + include/alibabacloud/imageenhan/model/AssessSharpnessResult.h + include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h + include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h + include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h + include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h + include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h + include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h + include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h + include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h + include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h + include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h + include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h + include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h + include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h + include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h + include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h + include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h + include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h + include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h + include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h + include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h + include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h + include/alibabacloud/imageenhan/model/RecolorHDImageResult.h + include/alibabacloud/imageenhan/model/RecolorImageRequest.h + include/alibabacloud/imageenhan/model/RecolorImageResult.h + include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h + include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h + include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h + include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h ) + +set(imageenhan_src + src/ImageenhanClient.cc + src/model/AssessCompositionRequest.cc + src/model/AssessCompositionResult.cc + src/model/AssessExposureRequest.cc + src/model/AssessExposureResult.cc + src/model/AssessSharpnessRequest.cc + src/model/AssessSharpnessResult.cc + src/model/ChangeImageSizeRequest.cc + src/model/ChangeImageSizeResult.cc + src/model/EnhanceImageColorRequest.cc + src/model/EnhanceImageColorResult.cc + src/model/ExtendImageStyleRequest.cc + src/model/ExtendImageStyleResult.cc + src/model/GenerateDynamicImageRequest.cc + src/model/GenerateDynamicImageResult.cc + src/model/GetAsyncJobResultRequest.cc + src/model/GetAsyncJobResultResult.cc + src/model/ImageBlindCharacterWatermarkRequest.cc + src/model/ImageBlindCharacterWatermarkResult.cc + src/model/ImageBlindPicWatermarkRequest.cc + src/model/ImageBlindPicWatermarkResult.cc + src/model/ImitatePhotoStyleRequest.cc + src/model/ImitatePhotoStyleResult.cc + src/model/IntelligentCompositionRequest.cc + src/model/IntelligentCompositionResult.cc + src/model/MakeSuperResolutionImageRequest.cc + src/model/MakeSuperResolutionImageResult.cc + src/model/RecolorHDImageRequest.cc + src/model/RecolorHDImageResult.cc + src/model/RecolorImageRequest.cc + src/model/RecolorImageResult.cc + src/model/RemoveImageSubtitlesRequest.cc + src/model/RemoveImageSubtitlesResult.cc + src/model/RemoveImageWatermarkRequest.cc + src/model/RemoveImageWatermarkResult.cc ) + +add_library(imageenhan ${LIB_TYPE} + ${imageenhan_public_header} + ${imageenhan_public_header_model} + ${imageenhan_src}) + +set_target_properties(imageenhan + PROPERTIES + LINKER_LANGUAGE CXX + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}imageenhan + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(imageenhan + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_IMAGEENHAN_LIBRARY) +endif() + +target_include_directories(imageenhan + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(imageenhan + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(imageenhan + jsoncpp) + target_include_directories(imageenhan + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(imageenhan + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(imageenhan + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(imageenhan + PRIVATE /usr/include/jsoncpp) + target_link_libraries(imageenhan + jsoncpp) +endif() + +install(FILES ${imageenhan_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan) +install(FILES ${imageenhan_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan/model) +install(TARGETS imageenhan + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h b/imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h new file mode 100644 index 000000000..065f65e2a --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h @@ -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 +#include +#include +#include +#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 AssessCompositionOutcome; + typedef std::future AssessCompositionOutcomeCallable; + typedef std::function&)> AssessCompositionAsyncHandler; + typedef Outcome AssessExposureOutcome; + typedef std::future AssessExposureOutcomeCallable; + typedef std::function&)> AssessExposureAsyncHandler; + typedef Outcome AssessSharpnessOutcome; + typedef std::future AssessSharpnessOutcomeCallable; + typedef std::function&)> AssessSharpnessAsyncHandler; + typedef Outcome ChangeImageSizeOutcome; + typedef std::future ChangeImageSizeOutcomeCallable; + typedef std::function&)> ChangeImageSizeAsyncHandler; + typedef Outcome EnhanceImageColorOutcome; + typedef std::future EnhanceImageColorOutcomeCallable; + typedef std::function&)> EnhanceImageColorAsyncHandler; + typedef Outcome ExtendImageStyleOutcome; + typedef std::future ExtendImageStyleOutcomeCallable; + typedef std::function&)> ExtendImageStyleAsyncHandler; + typedef Outcome GenerateDynamicImageOutcome; + typedef std::future GenerateDynamicImageOutcomeCallable; + typedef std::function&)> GenerateDynamicImageAsyncHandler; + typedef Outcome GetAsyncJobResultOutcome; + typedef std::future GetAsyncJobResultOutcomeCallable; + typedef std::function&)> GetAsyncJobResultAsyncHandler; + typedef Outcome ImageBlindCharacterWatermarkOutcome; + typedef std::future ImageBlindCharacterWatermarkOutcomeCallable; + typedef std::function&)> ImageBlindCharacterWatermarkAsyncHandler; + typedef Outcome ImageBlindPicWatermarkOutcome; + typedef std::future ImageBlindPicWatermarkOutcomeCallable; + typedef std::function&)> ImageBlindPicWatermarkAsyncHandler; + typedef Outcome ImitatePhotoStyleOutcome; + typedef std::future ImitatePhotoStyleOutcomeCallable; + typedef std::function&)> ImitatePhotoStyleAsyncHandler; + typedef Outcome IntelligentCompositionOutcome; + typedef std::future IntelligentCompositionOutcomeCallable; + typedef std::function&)> IntelligentCompositionAsyncHandler; + typedef Outcome MakeSuperResolutionImageOutcome; + typedef std::future MakeSuperResolutionImageOutcomeCallable; + typedef std::function&)> MakeSuperResolutionImageAsyncHandler; + typedef Outcome RecolorHDImageOutcome; + typedef std::future RecolorHDImageOutcomeCallable; + typedef std::function&)> RecolorHDImageAsyncHandler; + typedef Outcome RecolorImageOutcome; + typedef std::future RecolorImageOutcomeCallable; + typedef std::function&)> RecolorImageAsyncHandler; + typedef Outcome RemoveImageSubtitlesOutcome; + typedef std::future RemoveImageSubtitlesOutcomeCallable; + typedef std::function&)> RemoveImageSubtitlesAsyncHandler; + typedef Outcome RemoveImageWatermarkOutcome; + typedef std::future RemoveImageWatermarkOutcomeCallable; + typedef std::function&)> RemoveImageWatermarkAsyncHandler; + + ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration); + ImageenhanClient(const std::shared_ptr &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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; + RemoveImageWatermarkOutcomeCallable removeImageWatermarkCallable(const Model::RemoveImageWatermarkRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_ diff --git a/imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h b/imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h new file mode 100644 index 000000000..02d407aa8 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h @@ -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 + +#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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h new file mode 100644 index 000000000..271d75b77 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h new file mode 100644 index 000000000..64fb3ded5 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h new file mode 100644 index 000000000..5ef939b9d --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h new file mode 100644 index 000000000..5ecbc0d25 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h new file mode 100644 index 000000000..36ffb5627 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h b/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h new file mode 100644 index 000000000..69fcdc6e5 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h new file mode 100644 index 000000000..2a00f5f14 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h b/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h new file mode 100644 index 000000000..1eb733351 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h new file mode 100644 index 000000000..576b808a2 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h b/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h new file mode 100644 index 000000000..f5f2555ae --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h new file mode 100644 index 000000000..6be8fd85c --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h b/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h new file mode 100644 index 000000000..8b23d37c8 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h @@ -0,0 +1,56 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h new file mode 100644 index 000000000..c8f0fbf67 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h b/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h new file mode 100644 index 000000000..47db54e67 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h new file mode 100644 index 000000000..8207ba1fc --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h b/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h new file mode 100644 index 000000000..972a9ae23 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h @@ -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 +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h new file mode 100644 index 000000000..21266ceae --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h new file mode 100644 index 000000000..58e3cf798 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h @@ -0,0 +1,56 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h new file mode 100644 index 000000000..5d56e598e --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h new file mode 100644 index 000000000..62d5b8f77 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h @@ -0,0 +1,56 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h new file mode 100644 index 000000000..acf084ef7 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h b/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h new file mode 100644 index 000000000..461fa36e6 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h new file mode 100644 index 000000000..4c623008e --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h b/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h new file mode 100644 index 000000000..bea17084c --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h @@ -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 +#include +#include +#include +#include + +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 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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h new file mode 100644 index 000000000..529ca6573 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h b/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h new file mode 100644 index 000000000..f3dd9c31f --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h new file mode 100644 index 000000000..e02f12d4b --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h @@ -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 +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Imageenhan + { + namespace Model + { + class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageRequest : public RpcServiceRequest + { + public: + struct ColorTemplate + { + std::string color; + }; + + public: + RecolorHDImageRequest(); + ~RecolorHDImageRequest(); + + std::vector getColorTemplate()const; + void setColorTemplate(const std::vector& 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_; + std::string degree_; + std::string url_; + std::string mode_; + bool async_; + int colorCount_; + std::string refUrl_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageResult.h b/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageResult.h new file mode 100644 index 000000000..6c93fa40f --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Imageenhan + { + namespace Model + { + class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageResult : public ServiceResult + { + public: + struct Data + { + std::vector 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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h new file mode 100644 index 000000000..30ca62814 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h @@ -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 +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Imageenhan + { + namespace Model + { + class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageRequest : public RpcServiceRequest + { + public: + struct ColorTemplate + { + std::string color; + }; + + public: + RecolorImageRequest(); + ~RecolorImageRequest(); + + std::vector getColorTemplate()const; + void setColorTemplate(const std::vector& 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_; + std::string url_; + std::string mode_; + int colorCount_; + std::string refUrl_; + + }; + } + } +} +#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageResult.h b/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageResult.h new file mode 100644 index 000000000..87945e03e --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RecolorImageResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Imageenhan + { + namespace Model + { + class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageResult : public ServiceResult + { + public: + struct Data + { + std::vector 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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h new file mode 100644 index 000000000..bc4b7150f --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h @@ -0,0 +1,60 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h new file mode 100644 index 000000000..82b6f8b20 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h new file mode 100644 index 000000000..2021cda03 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h new file mode 100644 index 000000000..0d783bec5 --- /dev/null +++ b/imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_ +#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/imageenhan/src/ImageenhanClient.cc b/imageenhan/src/ImageenhanClient.cc new file mode 100644 index 000000000..a02f747f9 --- /dev/null +++ b/imageenhan/src/ImageenhanClient.cc @@ -0,0 +1,665 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +namespace +{ + const std::string SERVICE_NAME = "imageenhan"; +} + +ImageenhanClient::ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan"); +} + +ImageenhanClient::ImageenhanClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan"); +} + +ImageenhanClient::ImageenhanClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan"); +} + +ImageenhanClient::~ImageenhanClient() +{} + +ImageenhanClient::AssessCompositionOutcome ImageenhanClient::assessComposition(const AssessCompositionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AssessCompositionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AssessCompositionOutcome(AssessCompositionResult(outcome.result())); + else + return AssessCompositionOutcome(outcome.error()); +} + +void ImageenhanClient::assessCompositionAsync(const AssessCompositionRequest& request, const AssessCompositionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, assessComposition(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::AssessCompositionOutcomeCallable ImageenhanClient::assessCompositionCallable(const AssessCompositionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->assessComposition(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::AssessExposureOutcome ImageenhanClient::assessExposure(const AssessExposureRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AssessExposureOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AssessExposureOutcome(AssessExposureResult(outcome.result())); + else + return AssessExposureOutcome(outcome.error()); +} + +void ImageenhanClient::assessExposureAsync(const AssessExposureRequest& request, const AssessExposureAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, assessExposure(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::AssessExposureOutcomeCallable ImageenhanClient::assessExposureCallable(const AssessExposureRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->assessExposure(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::AssessSharpnessOutcome ImageenhanClient::assessSharpness(const AssessSharpnessRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AssessSharpnessOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AssessSharpnessOutcome(AssessSharpnessResult(outcome.result())); + else + return AssessSharpnessOutcome(outcome.error()); +} + +void ImageenhanClient::assessSharpnessAsync(const AssessSharpnessRequest& request, const AssessSharpnessAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, assessSharpness(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::AssessSharpnessOutcomeCallable ImageenhanClient::assessSharpnessCallable(const AssessSharpnessRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->assessSharpness(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::ChangeImageSizeOutcome ImageenhanClient::changeImageSize(const ChangeImageSizeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ChangeImageSizeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ChangeImageSizeOutcome(ChangeImageSizeResult(outcome.result())); + else + return ChangeImageSizeOutcome(outcome.error()); +} + +void ImageenhanClient::changeImageSizeAsync(const ChangeImageSizeRequest& request, const ChangeImageSizeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, changeImageSize(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::ChangeImageSizeOutcomeCallable ImageenhanClient::changeImageSizeCallable(const ChangeImageSizeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->changeImageSize(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::EnhanceImageColorOutcome ImageenhanClient::enhanceImageColor(const EnhanceImageColorRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnhanceImageColorOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnhanceImageColorOutcome(EnhanceImageColorResult(outcome.result())); + else + return EnhanceImageColorOutcome(outcome.error()); +} + +void ImageenhanClient::enhanceImageColorAsync(const EnhanceImageColorRequest& request, const EnhanceImageColorAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enhanceImageColor(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::EnhanceImageColorOutcomeCallable ImageenhanClient::enhanceImageColorCallable(const EnhanceImageColorRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enhanceImageColor(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::ExtendImageStyleOutcome ImageenhanClient::extendImageStyle(const ExtendImageStyleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ExtendImageStyleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ExtendImageStyleOutcome(ExtendImageStyleResult(outcome.result())); + else + return ExtendImageStyleOutcome(outcome.error()); +} + +void ImageenhanClient::extendImageStyleAsync(const ExtendImageStyleRequest& request, const ExtendImageStyleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, extendImageStyle(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::ExtendImageStyleOutcomeCallable ImageenhanClient::extendImageStyleCallable(const ExtendImageStyleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->extendImageStyle(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::GenerateDynamicImageOutcome ImageenhanClient::generateDynamicImage(const GenerateDynamicImageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GenerateDynamicImageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GenerateDynamicImageOutcome(GenerateDynamicImageResult(outcome.result())); + else + return GenerateDynamicImageOutcome(outcome.error()); +} + +void ImageenhanClient::generateDynamicImageAsync(const GenerateDynamicImageRequest& request, const GenerateDynamicImageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, generateDynamicImage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::GenerateDynamicImageOutcomeCallable ImageenhanClient::generateDynamicImageCallable(const GenerateDynamicImageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->generateDynamicImage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::GetAsyncJobResultOutcome ImageenhanClient::getAsyncJobResult(const GetAsyncJobResultRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetAsyncJobResultOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetAsyncJobResultOutcome(GetAsyncJobResultResult(outcome.result())); + else + return GetAsyncJobResultOutcome(outcome.error()); +} + +void ImageenhanClient::getAsyncJobResultAsync(const GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getAsyncJobResult(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::GetAsyncJobResultOutcomeCallable ImageenhanClient::getAsyncJobResultCallable(const GetAsyncJobResultRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getAsyncJobResult(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::ImageBlindCharacterWatermarkOutcome ImageenhanClient::imageBlindCharacterWatermark(const ImageBlindCharacterWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ImageBlindCharacterWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ImageBlindCharacterWatermarkOutcome(ImageBlindCharacterWatermarkResult(outcome.result())); + else + return ImageBlindCharacterWatermarkOutcome(outcome.error()); +} + +void ImageenhanClient::imageBlindCharacterWatermarkAsync(const ImageBlindCharacterWatermarkRequest& request, const ImageBlindCharacterWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, imageBlindCharacterWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::ImageBlindCharacterWatermarkOutcomeCallable ImageenhanClient::imageBlindCharacterWatermarkCallable(const ImageBlindCharacterWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->imageBlindCharacterWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::ImageBlindPicWatermarkOutcome ImageenhanClient::imageBlindPicWatermark(const ImageBlindPicWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ImageBlindPicWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ImageBlindPicWatermarkOutcome(ImageBlindPicWatermarkResult(outcome.result())); + else + return ImageBlindPicWatermarkOutcome(outcome.error()); +} + +void ImageenhanClient::imageBlindPicWatermarkAsync(const ImageBlindPicWatermarkRequest& request, const ImageBlindPicWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, imageBlindPicWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::ImageBlindPicWatermarkOutcomeCallable ImageenhanClient::imageBlindPicWatermarkCallable(const ImageBlindPicWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->imageBlindPicWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::ImitatePhotoStyleOutcome ImageenhanClient::imitatePhotoStyle(const ImitatePhotoStyleRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ImitatePhotoStyleOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ImitatePhotoStyleOutcome(ImitatePhotoStyleResult(outcome.result())); + else + return ImitatePhotoStyleOutcome(outcome.error()); +} + +void ImageenhanClient::imitatePhotoStyleAsync(const ImitatePhotoStyleRequest& request, const ImitatePhotoStyleAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, imitatePhotoStyle(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::ImitatePhotoStyleOutcomeCallable ImageenhanClient::imitatePhotoStyleCallable(const ImitatePhotoStyleRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->imitatePhotoStyle(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::IntelligentCompositionOutcome ImageenhanClient::intelligentComposition(const IntelligentCompositionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return IntelligentCompositionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return IntelligentCompositionOutcome(IntelligentCompositionResult(outcome.result())); + else + return IntelligentCompositionOutcome(outcome.error()); +} + +void ImageenhanClient::intelligentCompositionAsync(const IntelligentCompositionRequest& request, const IntelligentCompositionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, intelligentComposition(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::IntelligentCompositionOutcomeCallable ImageenhanClient::intelligentCompositionCallable(const IntelligentCompositionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->intelligentComposition(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::MakeSuperResolutionImageOutcome ImageenhanClient::makeSuperResolutionImage(const MakeSuperResolutionImageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return MakeSuperResolutionImageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return MakeSuperResolutionImageOutcome(MakeSuperResolutionImageResult(outcome.result())); + else + return MakeSuperResolutionImageOutcome(outcome.error()); +} + +void ImageenhanClient::makeSuperResolutionImageAsync(const MakeSuperResolutionImageRequest& request, const MakeSuperResolutionImageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, makeSuperResolutionImage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::MakeSuperResolutionImageOutcomeCallable ImageenhanClient::makeSuperResolutionImageCallable(const MakeSuperResolutionImageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->makeSuperResolutionImage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::RecolorHDImageOutcome ImageenhanClient::recolorHDImage(const RecolorHDImageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RecolorHDImageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RecolorHDImageOutcome(RecolorHDImageResult(outcome.result())); + else + return RecolorHDImageOutcome(outcome.error()); +} + +void ImageenhanClient::recolorHDImageAsync(const RecolorHDImageRequest& request, const RecolorHDImageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, recolorHDImage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::RecolorHDImageOutcomeCallable ImageenhanClient::recolorHDImageCallable(const RecolorHDImageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->recolorHDImage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::RecolorImageOutcome ImageenhanClient::recolorImage(const RecolorImageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RecolorImageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RecolorImageOutcome(RecolorImageResult(outcome.result())); + else + return RecolorImageOutcome(outcome.error()); +} + +void ImageenhanClient::recolorImageAsync(const RecolorImageRequest& request, const RecolorImageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, recolorImage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::RecolorImageOutcomeCallable ImageenhanClient::recolorImageCallable(const RecolorImageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->recolorImage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::RemoveImageSubtitlesOutcome ImageenhanClient::removeImageSubtitles(const RemoveImageSubtitlesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveImageSubtitlesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveImageSubtitlesOutcome(RemoveImageSubtitlesResult(outcome.result())); + else + return RemoveImageSubtitlesOutcome(outcome.error()); +} + +void ImageenhanClient::removeImageSubtitlesAsync(const RemoveImageSubtitlesRequest& request, const RemoveImageSubtitlesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeImageSubtitles(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::RemoveImageSubtitlesOutcomeCallable ImageenhanClient::removeImageSubtitlesCallable(const RemoveImageSubtitlesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeImageSubtitles(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ImageenhanClient::RemoveImageWatermarkOutcome ImageenhanClient::removeImageWatermark(const RemoveImageWatermarkRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveImageWatermarkOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveImageWatermarkOutcome(RemoveImageWatermarkResult(outcome.result())); + else + return RemoveImageWatermarkOutcome(outcome.error()); +} + +void ImageenhanClient::removeImageWatermarkAsync(const RemoveImageWatermarkRequest& request, const RemoveImageWatermarkAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeImageWatermark(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ImageenhanClient::RemoveImageWatermarkOutcomeCallable ImageenhanClient::removeImageWatermarkCallable(const RemoveImageWatermarkRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeImageWatermark(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/imageenhan/src/model/AssessCompositionRequest.cc b/imageenhan/src/model/AssessCompositionRequest.cc new file mode 100644 index 000000000..5e9dc4348 --- /dev/null +++ b/imageenhan/src/model/AssessCompositionRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::AssessCompositionRequest; + +AssessCompositionRequest::AssessCompositionRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "AssessComposition") +{ + setMethod(HttpRequest::Method::Post); +} + +AssessCompositionRequest::~AssessCompositionRequest() +{} + +std::string AssessCompositionRequest::getImageURL()const +{ + return imageURL_; +} + +void AssessCompositionRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/AssessCompositionResult.cc b/imageenhan/src/model/AssessCompositionResult.cc new file mode 100644 index 000000000..4389ba4d1 --- /dev/null +++ b/imageenhan/src/model/AssessCompositionResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +AssessCompositionResult::AssessCompositionResult() : + ServiceResult() +{} + +AssessCompositionResult::AssessCompositionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AssessCompositionResult::~AssessCompositionResult() +{} + +void AssessCompositionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Score"].isNull()) + data_.score = std::stof(dataNode["Score"].asString()); + +} + +AssessCompositionResult::Data AssessCompositionResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/AssessExposureRequest.cc b/imageenhan/src/model/AssessExposureRequest.cc new file mode 100644 index 000000000..6edc12277 --- /dev/null +++ b/imageenhan/src/model/AssessExposureRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::AssessExposureRequest; + +AssessExposureRequest::AssessExposureRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "AssessExposure") +{ + setMethod(HttpRequest::Method::Post); +} + +AssessExposureRequest::~AssessExposureRequest() +{} + +std::string AssessExposureRequest::getImageURL()const +{ + return imageURL_; +} + +void AssessExposureRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/AssessExposureResult.cc b/imageenhan/src/model/AssessExposureResult.cc new file mode 100644 index 000000000..e639a4632 --- /dev/null +++ b/imageenhan/src/model/AssessExposureResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +AssessExposureResult::AssessExposureResult() : + ServiceResult() +{} + +AssessExposureResult::AssessExposureResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AssessExposureResult::~AssessExposureResult() +{} + +void AssessExposureResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Exposure"].isNull()) + data_.exposure = std::stof(dataNode["Exposure"].asString()); + +} + +AssessExposureResult::Data AssessExposureResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/AssessSharpnessRequest.cc b/imageenhan/src/model/AssessSharpnessRequest.cc new file mode 100644 index 000000000..a2f638016 --- /dev/null +++ b/imageenhan/src/model/AssessSharpnessRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::AssessSharpnessRequest; + +AssessSharpnessRequest::AssessSharpnessRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "AssessSharpness") +{ + setMethod(HttpRequest::Method::Post); +} + +AssessSharpnessRequest::~AssessSharpnessRequest() +{} + +std::string AssessSharpnessRequest::getImageURL()const +{ + return imageURL_; +} + +void AssessSharpnessRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/AssessSharpnessResult.cc b/imageenhan/src/model/AssessSharpnessResult.cc new file mode 100644 index 000000000..2e5af4aec --- /dev/null +++ b/imageenhan/src/model/AssessSharpnessResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +AssessSharpnessResult::AssessSharpnessResult() : + ServiceResult() +{} + +AssessSharpnessResult::AssessSharpnessResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AssessSharpnessResult::~AssessSharpnessResult() +{} + +void AssessSharpnessResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Sharpness"].isNull()) + data_.sharpness = std::stof(dataNode["Sharpness"].asString()); + +} + +AssessSharpnessResult::Data AssessSharpnessResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/ChangeImageSizeRequest.cc b/imageenhan/src/model/ChangeImageSizeRequest.cc new file mode 100644 index 000000000..6760db0fe --- /dev/null +++ b/imageenhan/src/model/ChangeImageSizeRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::ChangeImageSizeRequest; + +ChangeImageSizeRequest::ChangeImageSizeRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "ChangeImageSize") +{ + setMethod(HttpRequest::Method::Post); +} + +ChangeImageSizeRequest::~ChangeImageSizeRequest() +{} + +std::string ChangeImageSizeRequest::getUrl()const +{ + return url_; +} + +void ChangeImageSizeRequest::setUrl(const std::string& url) +{ + url_ = url; + setBodyParameter("Url", url); +} + +int ChangeImageSizeRequest::getWidth()const +{ + return width_; +} + +void ChangeImageSizeRequest::setWidth(int width) +{ + width_ = width; + setBodyParameter("Width", std::to_string(width)); +} + +int ChangeImageSizeRequest::getHeight()const +{ + return height_; +} + +void ChangeImageSizeRequest::setHeight(int height) +{ + height_ = height; + setBodyParameter("Height", std::to_string(height)); +} + diff --git a/imageenhan/src/model/ChangeImageSizeResult.cc b/imageenhan/src/model/ChangeImageSizeResult.cc new file mode 100644 index 000000000..bbff038b5 --- /dev/null +++ b/imageenhan/src/model/ChangeImageSizeResult.cc @@ -0,0 +1,61 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +ChangeImageSizeResult::ChangeImageSizeResult() : + ServiceResult() +{} + +ChangeImageSizeResult::ChangeImageSizeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ChangeImageSizeResult::~ChangeImageSizeResult() +{} + +void ChangeImageSizeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Url"].isNull()) + data_.url = dataNode["Url"].asString(); + auto retainLocationNode = dataNode["RetainLocation"]; + if(!retainLocationNode["X"].isNull()) + data_.retainLocation.x = std::stoi(retainLocationNode["X"].asString()); + if(!retainLocationNode["Y"].isNull()) + data_.retainLocation.y = std::stoi(retainLocationNode["Y"].asString()); + if(!retainLocationNode["Width"].isNull()) + data_.retainLocation.width = std::stoi(retainLocationNode["Width"].asString()); + if(!retainLocationNode["Height"].isNull()) + data_.retainLocation.height = std::stoi(retainLocationNode["Height"].asString()); + +} + +ChangeImageSizeResult::Data ChangeImageSizeResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/EnhanceImageColorRequest.cc b/imageenhan/src/model/EnhanceImageColorRequest.cc new file mode 100644 index 000000000..3844a4b0a --- /dev/null +++ b/imageenhan/src/model/EnhanceImageColorRequest.cc @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::EnhanceImageColorRequest; + +EnhanceImageColorRequest::EnhanceImageColorRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "EnhanceImageColor") +{ + setMethod(HttpRequest::Method::Post); +} + +EnhanceImageColorRequest::~EnhanceImageColorRequest() +{} + +std::string EnhanceImageColorRequest::getMode()const +{ + return mode_; +} + +void EnhanceImageColorRequest::setMode(const std::string& mode) +{ + mode_ = mode; + setBodyParameter("Mode", mode); +} + +std::string EnhanceImageColorRequest::getImageURL()const +{ + return imageURL_; +} + +void EnhanceImageColorRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + +std::string EnhanceImageColorRequest::getOutputFormat()const +{ + return outputFormat_; +} + +void EnhanceImageColorRequest::setOutputFormat(const std::string& outputFormat) +{ + outputFormat_ = outputFormat; + setBodyParameter("OutputFormat", outputFormat); +} + diff --git a/imageenhan/src/model/EnhanceImageColorResult.cc b/imageenhan/src/model/EnhanceImageColorResult.cc new file mode 100644 index 000000000..674bafc5f --- /dev/null +++ b/imageenhan/src/model/EnhanceImageColorResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +EnhanceImageColorResult::EnhanceImageColorResult() : + ServiceResult() +{} + +EnhanceImageColorResult::EnhanceImageColorResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnhanceImageColorResult::~EnhanceImageColorResult() +{} + +void EnhanceImageColorResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["ImageURL"].isNull()) + data_.imageURL = dataNode["ImageURL"].asString(); + +} + +EnhanceImageColorResult::Data EnhanceImageColorResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/ExtendImageStyleRequest.cc b/imageenhan/src/model/ExtendImageStyleRequest.cc new file mode 100644 index 000000000..c3431d51a --- /dev/null +++ b/imageenhan/src/model/ExtendImageStyleRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::ExtendImageStyleRequest; + +ExtendImageStyleRequest::ExtendImageStyleRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "ExtendImageStyle") +{ + setMethod(HttpRequest::Method::Post); +} + +ExtendImageStyleRequest::~ExtendImageStyleRequest() +{} + +std::string ExtendImageStyleRequest::getMajorUrl()const +{ + return majorUrl_; +} + +void ExtendImageStyleRequest::setMajorUrl(const std::string& majorUrl) +{ + majorUrl_ = majorUrl; + setBodyParameter("MajorUrl", majorUrl); +} + +std::string ExtendImageStyleRequest::getStyleUrl()const +{ + return styleUrl_; +} + +void ExtendImageStyleRequest::setStyleUrl(const std::string& styleUrl) +{ + styleUrl_ = styleUrl; + setBodyParameter("StyleUrl", styleUrl); +} + diff --git a/imageenhan/src/model/ExtendImageStyleResult.cc b/imageenhan/src/model/ExtendImageStyleResult.cc new file mode 100644 index 000000000..fdacd4401 --- /dev/null +++ b/imageenhan/src/model/ExtendImageStyleResult.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +ExtendImageStyleResult::ExtendImageStyleResult() : + ServiceResult() +{} + +ExtendImageStyleResult::ExtendImageStyleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ExtendImageStyleResult::~ExtendImageStyleResult() +{} + +void ExtendImageStyleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Url"].isNull()) + data_.url = dataNode["Url"].asString(); + if(!dataNode["MajorUrl"].isNull()) + data_.majorUrl = dataNode["MajorUrl"].asString(); + +} + +ExtendImageStyleResult::Data ExtendImageStyleResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/GenerateDynamicImageRequest.cc b/imageenhan/src/model/GenerateDynamicImageRequest.cc new file mode 100644 index 000000000..b9c7b8979 --- /dev/null +++ b/imageenhan/src/model/GenerateDynamicImageRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::GenerateDynamicImageRequest; + +GenerateDynamicImageRequest::GenerateDynamicImageRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "GenerateDynamicImage") +{ + setMethod(HttpRequest::Method::Post); +} + +GenerateDynamicImageRequest::~GenerateDynamicImageRequest() +{} + +std::string GenerateDynamicImageRequest::getUrl()const +{ + return url_; +} + +void GenerateDynamicImageRequest::setUrl(const std::string& url) +{ + url_ = url; + setBodyParameter("Url", url); +} + +std::string GenerateDynamicImageRequest::getOperation()const +{ + return operation_; +} + +void GenerateDynamicImageRequest::setOperation(const std::string& operation) +{ + operation_ = operation; + setBodyParameter("Operation", operation); +} + diff --git a/imageenhan/src/model/GenerateDynamicImageResult.cc b/imageenhan/src/model/GenerateDynamicImageResult.cc new file mode 100644 index 000000000..46e8cdf23 --- /dev/null +++ b/imageenhan/src/model/GenerateDynamicImageResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +GenerateDynamicImageResult::GenerateDynamicImageResult() : + ServiceResult() +{} + +GenerateDynamicImageResult::GenerateDynamicImageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GenerateDynamicImageResult::~GenerateDynamicImageResult() +{} + +void GenerateDynamicImageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Url"].isNull()) + data_.url = dataNode["Url"].asString(); + +} + +GenerateDynamicImageResult::Data GenerateDynamicImageResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/GetAsyncJobResultRequest.cc b/imageenhan/src/model/GetAsyncJobResultRequest.cc new file mode 100644 index 000000000..a1a563e14 --- /dev/null +++ b/imageenhan/src/model/GetAsyncJobResultRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::GetAsyncJobResultRequest; + +GetAsyncJobResultRequest::GetAsyncJobResultRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "GetAsyncJobResult") +{ + setMethod(HttpRequest::Method::Post); +} + +GetAsyncJobResultRequest::~GetAsyncJobResultRequest() +{} + +bool GetAsyncJobResultRequest::getAsync()const +{ + return async_; +} + +void GetAsyncJobResultRequest::setAsync(bool async) +{ + async_ = async; + setBodyParameter("Async", async ? "true" : "false"); +} + +std::string GetAsyncJobResultRequest::getJobId()const +{ + return jobId_; +} + +void GetAsyncJobResultRequest::setJobId(const std::string& jobId) +{ + jobId_ = jobId; + setBodyParameter("JobId", jobId); +} + diff --git a/imageenhan/src/model/GetAsyncJobResultResult.cc b/imageenhan/src/model/GetAsyncJobResultResult.cc new file mode 100644 index 000000000..bb7f37ce0 --- /dev/null +++ b/imageenhan/src/model/GetAsyncJobResultResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +GetAsyncJobResultResult::GetAsyncJobResultResult() : + ServiceResult() +{} + +GetAsyncJobResultResult::GetAsyncJobResultResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetAsyncJobResultResult::~GetAsyncJobResultResult() +{} + +void GetAsyncJobResultResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["JobId"].isNull()) + data_.jobId = dataNode["JobId"].asString(); + if(!dataNode["Status"].isNull()) + data_.status = dataNode["Status"].asString(); + if(!dataNode["Result"].isNull()) + data_.result = dataNode["Result"].asString(); + if(!dataNode["ErrorCode"].isNull()) + data_.errorCode = dataNode["ErrorCode"].asString(); + if(!dataNode["ErrorMessage"].isNull()) + data_.errorMessage = dataNode["ErrorMessage"].asString(); + +} + +GetAsyncJobResultResult::Data GetAsyncJobResultResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc b/imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc new file mode 100644 index 000000000..786c222da --- /dev/null +++ b/imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::ImageBlindCharacterWatermarkRequest; + +ImageBlindCharacterWatermarkRequest::ImageBlindCharacterWatermarkRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindCharacterWatermark") +{ + setMethod(HttpRequest::Method::Post); +} + +ImageBlindCharacterWatermarkRequest::~ImageBlindCharacterWatermarkRequest() +{} + +std::string ImageBlindCharacterWatermarkRequest::getWatermarkImageURL()const +{ + return watermarkImageURL_; +} + +void ImageBlindCharacterWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL) +{ + watermarkImageURL_ = watermarkImageURL; + setBodyParameter("WatermarkImageURL", watermarkImageURL); +} + +int ImageBlindCharacterWatermarkRequest::getQualityFactor()const +{ + return qualityFactor_; +} + +void ImageBlindCharacterWatermarkRequest::setQualityFactor(int qualityFactor) +{ + qualityFactor_ = qualityFactor; + setBodyParameter("QualityFactor", std::to_string(qualityFactor)); +} + +std::string ImageBlindCharacterWatermarkRequest::getFunctionType()const +{ + return functionType_; +} + +void ImageBlindCharacterWatermarkRequest::setFunctionType(const std::string& functionType) +{ + functionType_ = functionType; + setBodyParameter("FunctionType", functionType); +} + +std::string ImageBlindCharacterWatermarkRequest::getOutputFileType()const +{ + return outputFileType_; +} + +void ImageBlindCharacterWatermarkRequest::setOutputFileType(const std::string& outputFileType) +{ + outputFileType_ = outputFileType; + setBodyParameter("OutputFileType", outputFileType); +} + +std::string ImageBlindCharacterWatermarkRequest::getOriginImageURL()const +{ + return originImageURL_; +} + +void ImageBlindCharacterWatermarkRequest::setOriginImageURL(const std::string& originImageURL) +{ + originImageURL_ = originImageURL; + setBodyParameter("OriginImageURL", originImageURL); +} + +std::string ImageBlindCharacterWatermarkRequest::getText()const +{ + return text_; +} + +void ImageBlindCharacterWatermarkRequest::setText(const std::string& text) +{ + text_ = text; + setBodyParameter("Text", text); +} + diff --git a/imageenhan/src/model/ImageBlindCharacterWatermarkResult.cc b/imageenhan/src/model/ImageBlindCharacterWatermarkResult.cc new file mode 100644 index 000000000..18054e0ab --- /dev/null +++ b/imageenhan/src/model/ImageBlindCharacterWatermarkResult.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +ImageBlindCharacterWatermarkResult::ImageBlindCharacterWatermarkResult() : + ServiceResult() +{} + +ImageBlindCharacterWatermarkResult::ImageBlindCharacterWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ImageBlindCharacterWatermarkResult::~ImageBlindCharacterWatermarkResult() +{} + +void ImageBlindCharacterWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["WatermarkImageURL"].isNull()) + data_.watermarkImageURL = dataNode["WatermarkImageURL"].asString(); + if(!dataNode["TextImageURL"].isNull()) + data_.textImageURL = dataNode["TextImageURL"].asString(); + +} + +ImageBlindCharacterWatermarkResult::Data ImageBlindCharacterWatermarkResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/ImageBlindPicWatermarkRequest.cc b/imageenhan/src/model/ImageBlindPicWatermarkRequest.cc new file mode 100644 index 000000000..4f04ce3b2 --- /dev/null +++ b/imageenhan/src/model/ImageBlindPicWatermarkRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::ImageBlindPicWatermarkRequest; + +ImageBlindPicWatermarkRequest::ImageBlindPicWatermarkRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindPicWatermark") +{ + setMethod(HttpRequest::Method::Post); +} + +ImageBlindPicWatermarkRequest::~ImageBlindPicWatermarkRequest() +{} + +std::string ImageBlindPicWatermarkRequest::getWatermarkImageURL()const +{ + return watermarkImageURL_; +} + +void ImageBlindPicWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL) +{ + watermarkImageURL_ = watermarkImageURL; + setBodyParameter("WatermarkImageURL", watermarkImageURL); +} + +int ImageBlindPicWatermarkRequest::getQualityFactor()const +{ + return qualityFactor_; +} + +void ImageBlindPicWatermarkRequest::setQualityFactor(int qualityFactor) +{ + qualityFactor_ = qualityFactor; + setBodyParameter("QualityFactor", std::to_string(qualityFactor)); +} + +std::string ImageBlindPicWatermarkRequest::getFunctionType()const +{ + return functionType_; +} + +void ImageBlindPicWatermarkRequest::setFunctionType(const std::string& functionType) +{ + functionType_ = functionType; + setBodyParameter("FunctionType", functionType); +} + +std::string ImageBlindPicWatermarkRequest::getLogoURL()const +{ + return logoURL_; +} + +void ImageBlindPicWatermarkRequest::setLogoURL(const std::string& logoURL) +{ + logoURL_ = logoURL; + setBodyParameter("LogoURL", logoURL); +} + +std::string ImageBlindPicWatermarkRequest::getOutputFileType()const +{ + return outputFileType_; +} + +void ImageBlindPicWatermarkRequest::setOutputFileType(const std::string& outputFileType) +{ + outputFileType_ = outputFileType; + setBodyParameter("OutputFileType", outputFileType); +} + +std::string ImageBlindPicWatermarkRequest::getOriginImageURL()const +{ + return originImageURL_; +} + +void ImageBlindPicWatermarkRequest::setOriginImageURL(const std::string& originImageURL) +{ + originImageURL_ = originImageURL; + setBodyParameter("OriginImageURL", originImageURL); +} + diff --git a/imageenhan/src/model/ImageBlindPicWatermarkResult.cc b/imageenhan/src/model/ImageBlindPicWatermarkResult.cc new file mode 100644 index 000000000..f914ebbf5 --- /dev/null +++ b/imageenhan/src/model/ImageBlindPicWatermarkResult.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +ImageBlindPicWatermarkResult::ImageBlindPicWatermarkResult() : + ServiceResult() +{} + +ImageBlindPicWatermarkResult::ImageBlindPicWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ImageBlindPicWatermarkResult::~ImageBlindPicWatermarkResult() +{} + +void ImageBlindPicWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["WatermarkImageURL"].isNull()) + data_.watermarkImageURL = dataNode["WatermarkImageURL"].asString(); + if(!dataNode["LogoURL"].isNull()) + data_.logoURL = dataNode["LogoURL"].asString(); + +} + +ImageBlindPicWatermarkResult::Data ImageBlindPicWatermarkResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/ImitatePhotoStyleRequest.cc b/imageenhan/src/model/ImitatePhotoStyleRequest.cc new file mode 100644 index 000000000..be578f340 --- /dev/null +++ b/imageenhan/src/model/ImitatePhotoStyleRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::ImitatePhotoStyleRequest; + +ImitatePhotoStyleRequest::ImitatePhotoStyleRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "ImitatePhotoStyle") +{ + setMethod(HttpRequest::Method::Post); +} + +ImitatePhotoStyleRequest::~ImitatePhotoStyleRequest() +{} + +std::string ImitatePhotoStyleRequest::getStyleUrl()const +{ + return styleUrl_; +} + +void ImitatePhotoStyleRequest::setStyleUrl(const std::string& styleUrl) +{ + styleUrl_ = styleUrl; + setBodyParameter("StyleUrl", styleUrl); +} + +std::string ImitatePhotoStyleRequest::getImageURL()const +{ + return imageURL_; +} + +void ImitatePhotoStyleRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/ImitatePhotoStyleResult.cc b/imageenhan/src/model/ImitatePhotoStyleResult.cc new file mode 100644 index 000000000..d6777c16b --- /dev/null +++ b/imageenhan/src/model/ImitatePhotoStyleResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +ImitatePhotoStyleResult::ImitatePhotoStyleResult() : + ServiceResult() +{} + +ImitatePhotoStyleResult::ImitatePhotoStyleResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ImitatePhotoStyleResult::~ImitatePhotoStyleResult() +{} + +void ImitatePhotoStyleResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["ImageURL"].isNull()) + data_.imageURL = dataNode["ImageURL"].asString(); + +} + +ImitatePhotoStyleResult::Data ImitatePhotoStyleResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/IntelligentCompositionRequest.cc b/imageenhan/src/model/IntelligentCompositionRequest.cc new file mode 100644 index 000000000..4ffc44fce --- /dev/null +++ b/imageenhan/src/model/IntelligentCompositionRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::IntelligentCompositionRequest; + +IntelligentCompositionRequest::IntelligentCompositionRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "IntelligentComposition") +{ + setMethod(HttpRequest::Method::Post); +} + +IntelligentCompositionRequest::~IntelligentCompositionRequest() +{} + +int IntelligentCompositionRequest::getNumBoxes()const +{ + return numBoxes_; +} + +void IntelligentCompositionRequest::setNumBoxes(int numBoxes) +{ + numBoxes_ = numBoxes; + setBodyParameter("NumBoxes", std::to_string(numBoxes)); +} + +std::string IntelligentCompositionRequest::getImageURL()const +{ + return imageURL_; +} + +void IntelligentCompositionRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/IntelligentCompositionResult.cc b/imageenhan/src/model/IntelligentCompositionResult.cc new file mode 100644 index 000000000..f41e1a853 --- /dev/null +++ b/imageenhan/src/model/IntelligentCompositionResult.cc @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +IntelligentCompositionResult::IntelligentCompositionResult() : + ServiceResult() +{} + +IntelligentCompositionResult::IntelligentCompositionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +IntelligentCompositionResult::~IntelligentCompositionResult() +{} + +void IntelligentCompositionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allElementsNode = dataNode["Elements"]["Element"]; + for (auto dataNodeElementsElement : allElementsNode) + { + Data::Element elementObject; + if(!dataNodeElementsElement["MinX"].isNull()) + elementObject.minX = std::stoi(dataNodeElementsElement["MinX"].asString()); + if(!dataNodeElementsElement["MinY"].isNull()) + elementObject.minY = std::stoi(dataNodeElementsElement["MinY"].asString()); + if(!dataNodeElementsElement["MaxX"].isNull()) + elementObject.maxX = std::stoi(dataNodeElementsElement["MaxX"].asString()); + if(!dataNodeElementsElement["MaxY"].isNull()) + elementObject.maxY = std::stoi(dataNodeElementsElement["MaxY"].asString()); + if(!dataNodeElementsElement["Score"].isNull()) + elementObject.score = std::stof(dataNodeElementsElement["Score"].asString()); + data_.elements.push_back(elementObject); + } + +} + +IntelligentCompositionResult::Data IntelligentCompositionResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/MakeSuperResolutionImageRequest.cc b/imageenhan/src/model/MakeSuperResolutionImageRequest.cc new file mode 100644 index 000000000..4dac7f75b --- /dev/null +++ b/imageenhan/src/model/MakeSuperResolutionImageRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::MakeSuperResolutionImageRequest; + +MakeSuperResolutionImageRequest::MakeSuperResolutionImageRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "MakeSuperResolutionImage") +{ + setMethod(HttpRequest::Method::Post); +} + +MakeSuperResolutionImageRequest::~MakeSuperResolutionImageRequest() +{} + +std::string MakeSuperResolutionImageRequest::getUrl()const +{ + return url_; +} + +void MakeSuperResolutionImageRequest::setUrl(const std::string& url) +{ + url_ = url; + setBodyParameter("Url", url); +} + diff --git a/imageenhan/src/model/MakeSuperResolutionImageResult.cc b/imageenhan/src/model/MakeSuperResolutionImageResult.cc new file mode 100644 index 000000000..0d1939eff --- /dev/null +++ b/imageenhan/src/model/MakeSuperResolutionImageResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +MakeSuperResolutionImageResult::MakeSuperResolutionImageResult() : + ServiceResult() +{} + +MakeSuperResolutionImageResult::MakeSuperResolutionImageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +MakeSuperResolutionImageResult::~MakeSuperResolutionImageResult() +{} + +void MakeSuperResolutionImageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Url"].isNull()) + data_.url = dataNode["Url"].asString(); + +} + +MakeSuperResolutionImageResult::Data MakeSuperResolutionImageResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/RecolorHDImageRequest.cc b/imageenhan/src/model/RecolorHDImageRequest.cc new file mode 100644 index 000000000..db2ac48f2 --- /dev/null +++ b/imageenhan/src/model/RecolorHDImageRequest.cc @@ -0,0 +1,110 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::RecolorHDImageRequest; + +RecolorHDImageRequest::RecolorHDImageRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "RecolorHDImage") +{ + setMethod(HttpRequest::Method::Post); +} + +RecolorHDImageRequest::~RecolorHDImageRequest() +{} + +std::vector RecolorHDImageRequest::getColorTemplate()const +{ + return colorTemplate_; +} + +void RecolorHDImageRequest::setColorTemplate(const std::vector& colorTemplate) +{ + colorTemplate_ = colorTemplate; + for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) { + auto colorTemplateObj = colorTemplate.at(dep1); + std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1); + setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color); + } +} + +std::string RecolorHDImageRequest::getDegree()const +{ + return degree_; +} + +void RecolorHDImageRequest::setDegree(const std::string& degree) +{ + degree_ = degree; + setBodyParameter("Degree", degree); +} + +std::string RecolorHDImageRequest::getUrl()const +{ + return url_; +} + +void RecolorHDImageRequest::setUrl(const std::string& url) +{ + url_ = url; + setBodyParameter("Url", url); +} + +std::string RecolorHDImageRequest::getMode()const +{ + return mode_; +} + +void RecolorHDImageRequest::setMode(const std::string& mode) +{ + mode_ = mode; + setBodyParameter("Mode", mode); +} + +bool RecolorHDImageRequest::getAsync()const +{ + return async_; +} + +void RecolorHDImageRequest::setAsync(bool async) +{ + async_ = async; + setBodyParameter("Async", async ? "true" : "false"); +} + +int RecolorHDImageRequest::getColorCount()const +{ + return colorCount_; +} + +void RecolorHDImageRequest::setColorCount(int colorCount) +{ + colorCount_ = colorCount; + setBodyParameter("ColorCount", std::to_string(colorCount)); +} + +std::string RecolorHDImageRequest::getRefUrl()const +{ + return refUrl_; +} + +void RecolorHDImageRequest::setRefUrl(const std::string& refUrl) +{ + refUrl_ = refUrl; + setBodyParameter("RefUrl", refUrl); +} + diff --git a/imageenhan/src/model/RecolorHDImageResult.cc b/imageenhan/src/model/RecolorHDImageResult.cc new file mode 100644 index 000000000..e806ee02e --- /dev/null +++ b/imageenhan/src/model/RecolorHDImageResult.cc @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +RecolorHDImageResult::RecolorHDImageResult() : + ServiceResult() +{} + +RecolorHDImageResult::RecolorHDImageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RecolorHDImageResult::~RecolorHDImageResult() +{} + +void RecolorHDImageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allImageList = dataNode["ImageList"]["ImageList"]; + for (auto value : allImageList) + data_.imageList.push_back(value.asString()); + +} + +RecolorHDImageResult::Data RecolorHDImageResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/RecolorImageRequest.cc b/imageenhan/src/model/RecolorImageRequest.cc new file mode 100644 index 000000000..2d354ae3d --- /dev/null +++ b/imageenhan/src/model/RecolorImageRequest.cc @@ -0,0 +1,88 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::RecolorImageRequest; + +RecolorImageRequest::RecolorImageRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "RecolorImage") +{ + setMethod(HttpRequest::Method::Post); +} + +RecolorImageRequest::~RecolorImageRequest() +{} + +std::vector RecolorImageRequest::getColorTemplate()const +{ + return colorTemplate_; +} + +void RecolorImageRequest::setColorTemplate(const std::vector& colorTemplate) +{ + colorTemplate_ = colorTemplate; + for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) { + auto colorTemplateObj = colorTemplate.at(dep1); + std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1); + setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color); + } +} + +std::string RecolorImageRequest::getUrl()const +{ + return url_; +} + +void RecolorImageRequest::setUrl(const std::string& url) +{ + url_ = url; + setBodyParameter("Url", url); +} + +std::string RecolorImageRequest::getMode()const +{ + return mode_; +} + +void RecolorImageRequest::setMode(const std::string& mode) +{ + mode_ = mode; + setBodyParameter("Mode", mode); +} + +int RecolorImageRequest::getColorCount()const +{ + return colorCount_; +} + +void RecolorImageRequest::setColorCount(int colorCount) +{ + colorCount_ = colorCount; + setBodyParameter("ColorCount", std::to_string(colorCount)); +} + +std::string RecolorImageRequest::getRefUrl()const +{ + return refUrl_; +} + +void RecolorImageRequest::setRefUrl(const std::string& refUrl) +{ + refUrl_ = refUrl; + setBodyParameter("RefUrl", refUrl); +} + diff --git a/imageenhan/src/model/RecolorImageResult.cc b/imageenhan/src/model/RecolorImageResult.cc new file mode 100644 index 000000000..4f12dc941 --- /dev/null +++ b/imageenhan/src/model/RecolorImageResult.cc @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +RecolorImageResult::RecolorImageResult() : + ServiceResult() +{} + +RecolorImageResult::RecolorImageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RecolorImageResult::~RecolorImageResult() +{} + +void RecolorImageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allImageList = dataNode["ImageList"]["ImageList"]; + for (auto value : allImageList) + data_.imageList.push_back(value.asString()); + +} + +RecolorImageResult::Data RecolorImageResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/RemoveImageSubtitlesRequest.cc b/imageenhan/src/model/RemoveImageSubtitlesRequest.cc new file mode 100644 index 000000000..8f0ce944e --- /dev/null +++ b/imageenhan/src/model/RemoveImageSubtitlesRequest.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::RemoveImageSubtitlesRequest; + +RemoveImageSubtitlesRequest::RemoveImageSubtitlesRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageSubtitles") +{ + setMethod(HttpRequest::Method::Post); +} + +RemoveImageSubtitlesRequest::~RemoveImageSubtitlesRequest() +{} + +float RemoveImageSubtitlesRequest::getBH()const +{ + return bH_; +} + +void RemoveImageSubtitlesRequest::setBH(float bH) +{ + bH_ = bH; + setBodyParameter("BH", std::to_string(bH)); +} + +float RemoveImageSubtitlesRequest::getBW()const +{ + return bW_; +} + +void RemoveImageSubtitlesRequest::setBW(float bW) +{ + bW_ = bW; + setBodyParameter("BW", std::to_string(bW)); +} + +float RemoveImageSubtitlesRequest::getBX()const +{ + return bX_; +} + +void RemoveImageSubtitlesRequest::setBX(float bX) +{ + bX_ = bX; + setBodyParameter("BX", std::to_string(bX)); +} + +std::string RemoveImageSubtitlesRequest::getImageURL()const +{ + return imageURL_; +} + +void RemoveImageSubtitlesRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + +float RemoveImageSubtitlesRequest::getBY()const +{ + return bY_; +} + +void RemoveImageSubtitlesRequest::setBY(float bY) +{ + bY_ = bY; + setBodyParameter("BY", std::to_string(bY)); +} + diff --git a/imageenhan/src/model/RemoveImageSubtitlesResult.cc b/imageenhan/src/model/RemoveImageSubtitlesResult.cc new file mode 100644 index 000000000..c4d2aeb8f --- /dev/null +++ b/imageenhan/src/model/RemoveImageSubtitlesResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +RemoveImageSubtitlesResult::RemoveImageSubtitlesResult() : + ServiceResult() +{} + +RemoveImageSubtitlesResult::RemoveImageSubtitlesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveImageSubtitlesResult::~RemoveImageSubtitlesResult() +{} + +void RemoveImageSubtitlesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["ImageURL"].isNull()) + data_.imageURL = dataNode["ImageURL"].asString(); + +} + +RemoveImageSubtitlesResult::Data RemoveImageSubtitlesResult::getData()const +{ + return data_; +} + diff --git a/imageenhan/src/model/RemoveImageWatermarkRequest.cc b/imageenhan/src/model/RemoveImageWatermarkRequest.cc new file mode 100644 index 000000000..dc361a678 --- /dev/null +++ b/imageenhan/src/model/RemoveImageWatermarkRequest.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Imageenhan::Model::RemoveImageWatermarkRequest; + +RemoveImageWatermarkRequest::RemoveImageWatermarkRequest() : + RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageWatermark") +{ + setMethod(HttpRequest::Method::Post); +} + +RemoveImageWatermarkRequest::~RemoveImageWatermarkRequest() +{} + +std::string RemoveImageWatermarkRequest::getImageURL()const +{ + return imageURL_; +} + +void RemoveImageWatermarkRequest::setImageURL(const std::string& imageURL) +{ + imageURL_ = imageURL; + setBodyParameter("ImageURL", imageURL); +} + diff --git a/imageenhan/src/model/RemoveImageWatermarkResult.cc b/imageenhan/src/model/RemoveImageWatermarkResult.cc new file mode 100644 index 000000000..380e87cfa --- /dev/null +++ b/imageenhan/src/model/RemoveImageWatermarkResult.cc @@ -0,0 +1,52 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Imageenhan; +using namespace AlibabaCloud::Imageenhan::Model; + +RemoveImageWatermarkResult::RemoveImageWatermarkResult() : + ServiceResult() +{} + +RemoveImageWatermarkResult::RemoveImageWatermarkResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveImageWatermarkResult::~RemoveImageWatermarkResult() +{} + +void RemoveImageWatermarkResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["ImageURL"].isNull()) + data_.imageURL = dataNode["ImageURL"].asString(); + +} + +RemoveImageWatermarkResult::Data RemoveImageWatermarkResult::getData()const +{ + return data_; +} +