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

Release ChangeSky.

Browse Source
This commit is contained in:
sdk-team
2020-09-09 11:48:18 +00:00
parent 061f62c362
commit d6292fe40b
81 changed files with 5026 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-09-09 Version: patch
- Release ChangeSky.
2020-09-09 Version: patch
- Release DetectChefCap.

158
imageseg/CMakeLists.txt Normal file
View File

@@ -0,0 +1,158 @@
#
# 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(imageseg_public_header
include/alibabacloud/imageseg/ImagesegClient.h
include/alibabacloud/imageseg/ImagesegExport.h )
set(imageseg_public_header_model
include/alibabacloud/imageseg/model/ChangeSkyRequest.h
include/alibabacloud/imageseg/model/ChangeSkyResult.h
include/alibabacloud/imageseg/model/GetAsyncJobResultRequest.h
include/alibabacloud/imageseg/model/GetAsyncJobResultResult.h
include/alibabacloud/imageseg/model/ParseFaceRequest.h
include/alibabacloud/imageseg/model/ParseFaceResult.h
include/alibabacloud/imageseg/model/RefineMaskRequest.h
include/alibabacloud/imageseg/model/RefineMaskResult.h
include/alibabacloud/imageseg/model/SegmentAnimalRequest.h
include/alibabacloud/imageseg/model/SegmentAnimalResult.h
include/alibabacloud/imageseg/model/SegmentBodyRequest.h
include/alibabacloud/imageseg/model/SegmentBodyResult.h
include/alibabacloud/imageseg/model/SegmentClothRequest.h
include/alibabacloud/imageseg/model/SegmentClothResult.h
include/alibabacloud/imageseg/model/SegmentCommodityRequest.h
include/alibabacloud/imageseg/model/SegmentCommodityResult.h
include/alibabacloud/imageseg/model/SegmentCommonImageRequest.h
include/alibabacloud/imageseg/model/SegmentCommonImageResult.h
include/alibabacloud/imageseg/model/SegmentFaceRequest.h
include/alibabacloud/imageseg/model/SegmentFaceResult.h
include/alibabacloud/imageseg/model/SegmentFoodRequest.h
include/alibabacloud/imageseg/model/SegmentFoodResult.h
include/alibabacloud/imageseg/model/SegmentFurnitureRequest.h
include/alibabacloud/imageseg/model/SegmentFurnitureResult.h
include/alibabacloud/imageseg/model/SegmentHDBodyRequest.h
include/alibabacloud/imageseg/model/SegmentHDBodyResult.h
include/alibabacloud/imageseg/model/SegmentHairRequest.h
include/alibabacloud/imageseg/model/SegmentHairResult.h
include/alibabacloud/imageseg/model/SegmentHeadRequest.h
include/alibabacloud/imageseg/model/SegmentHeadResult.h
include/alibabacloud/imageseg/model/SegmentLogoRequest.h
include/alibabacloud/imageseg/model/SegmentLogoResult.h
include/alibabacloud/imageseg/model/SegmentSceneRequest.h
include/alibabacloud/imageseg/model/SegmentSceneResult.h
include/alibabacloud/imageseg/model/SegmentSkyRequest.h
include/alibabacloud/imageseg/model/SegmentSkyResult.h
include/alibabacloud/imageseg/model/SegmentVehicleRequest.h
include/alibabacloud/imageseg/model/SegmentVehicleResult.h )
set(imageseg_src
src/ImagesegClient.cc
src/model/ChangeSkyRequest.cc
src/model/ChangeSkyResult.cc
src/model/GetAsyncJobResultRequest.cc
src/model/GetAsyncJobResultResult.cc
src/model/ParseFaceRequest.cc
src/model/ParseFaceResult.cc
src/model/RefineMaskRequest.cc
src/model/RefineMaskResult.cc
src/model/SegmentAnimalRequest.cc
src/model/SegmentAnimalResult.cc
src/model/SegmentBodyRequest.cc
src/model/SegmentBodyResult.cc
src/model/SegmentClothRequest.cc
src/model/SegmentClothResult.cc
src/model/SegmentCommodityRequest.cc
src/model/SegmentCommodityResult.cc
src/model/SegmentCommonImageRequest.cc
src/model/SegmentCommonImageResult.cc
src/model/SegmentFaceRequest.cc
src/model/SegmentFaceResult.cc
src/model/SegmentFoodRequest.cc
src/model/SegmentFoodResult.cc
src/model/SegmentFurnitureRequest.cc
src/model/SegmentFurnitureResult.cc
src/model/SegmentHDBodyRequest.cc
src/model/SegmentHDBodyResult.cc
src/model/SegmentHairRequest.cc
src/model/SegmentHairResult.cc
src/model/SegmentHeadRequest.cc
src/model/SegmentHeadResult.cc
src/model/SegmentLogoRequest.cc
src/model/SegmentLogoResult.cc
src/model/SegmentSceneRequest.cc
src/model/SegmentSceneResult.cc
src/model/SegmentSkyRequest.cc
src/model/SegmentSkyResult.cc
src/model/SegmentVehicleRequest.cc
src/model/SegmentVehicleResult.cc )
add_library(imageseg ${LIB_TYPE}
${imageseg_public_header}
${imageseg_public_header_model}
${imageseg_src})
set_target_properties(imageseg
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}imageseg
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(imageseg
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_IMAGESEG_LIBRARY)
endif()
target_include_directories(imageseg
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(imageseg
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(imageseg
jsoncpp)
target_include_directories(imageseg
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(imageseg
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(imageseg
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(imageseg
PRIVATE /usr/include/jsoncpp)
target_link_libraries(imageseg
jsoncpp)
endif()
install(FILES ${imageseg_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageseg)
install(FILES ${imageseg_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageseg/model)
install(TARGETS imageseg
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

198
imageseg/include/alibabacloud/imageseg/ImagesegClient.h Normal file
View File

@@ -0,0 +1,198 @@
/*
* 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_IMAGESEG_IMAGESEGCLIENT_H_
#define ALIBABACLOUD_IMAGESEG_IMAGESEGCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ImagesegExport.h"
#include "model/ChangeSkyRequest.h"
#include "model/ChangeSkyResult.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/ParseFaceRequest.h"
#include "model/ParseFaceResult.h"
#include "model/RefineMaskRequest.h"
#include "model/RefineMaskResult.h"
#include "model/SegmentAnimalRequest.h"
#include "model/SegmentAnimalResult.h"
#include "model/SegmentBodyRequest.h"
#include "model/SegmentBodyResult.h"
#include "model/SegmentClothRequest.h"
#include "model/SegmentClothResult.h"
#include "model/SegmentCommodityRequest.h"
#include "model/SegmentCommodityResult.h"
#include "model/SegmentCommonImageRequest.h"
#include "model/SegmentCommonImageResult.h"
#include "model/SegmentFaceRequest.h"
#include "model/SegmentFaceResult.h"
#include "model/SegmentFoodRequest.h"
#include "model/SegmentFoodResult.h"
#include "model/SegmentFurnitureRequest.h"
#include "model/SegmentFurnitureResult.h"
#include "model/SegmentHDBodyRequest.h"
#include "model/SegmentHDBodyResult.h"
#include "model/SegmentHairRequest.h"
#include "model/SegmentHairResult.h"
#include "model/SegmentHeadRequest.h"
#include "model/SegmentHeadResult.h"
#include "model/SegmentLogoRequest.h"
#include "model/SegmentLogoResult.h"
#include "model/SegmentSceneRequest.h"
#include "model/SegmentSceneResult.h"
#include "model/SegmentSkyRequest.h"
#include "model/SegmentSkyResult.h"
#include "model/SegmentVehicleRequest.h"
#include "model/SegmentVehicleResult.h"
namespace AlibabaCloud
{
namespace Imageseg
{
class ALIBABACLOUD_IMAGESEG_EXPORT ImagesegClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ChangeSkyResult> ChangeSkyOutcome;
typedef std::future<ChangeSkyOutcome> ChangeSkyOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::ChangeSkyRequest&, const ChangeSkyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeSkyAsyncHandler;
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::ParseFaceResult> ParseFaceOutcome;
typedef std::future<ParseFaceOutcome> ParseFaceOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::ParseFaceRequest&, const ParseFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ParseFaceAsyncHandler;
typedef Outcome<Error, Model::RefineMaskResult> RefineMaskOutcome;
typedef std::future<RefineMaskOutcome> RefineMaskOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::RefineMaskRequest&, const RefineMaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefineMaskAsyncHandler;
typedef Outcome<Error, Model::SegmentAnimalResult> SegmentAnimalOutcome;
typedef std::future<SegmentAnimalOutcome> SegmentAnimalOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentAnimalRequest&, const SegmentAnimalOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentAnimalAsyncHandler;
typedef Outcome<Error, Model::SegmentBodyResult> SegmentBodyOutcome;
typedef std::future<SegmentBodyOutcome> SegmentBodyOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentBodyRequest&, const SegmentBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentBodyAsyncHandler;
typedef Outcome<Error, Model::SegmentClothResult> SegmentClothOutcome;
typedef std::future<SegmentClothOutcome> SegmentClothOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentClothRequest&, const SegmentClothOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentClothAsyncHandler;
typedef Outcome<Error, Model::SegmentCommodityResult> SegmentCommodityOutcome;
typedef std::future<SegmentCommodityOutcome> SegmentCommodityOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentCommodityRequest&, const SegmentCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentCommodityAsyncHandler;
typedef Outcome<Error, Model::SegmentCommonImageResult> SegmentCommonImageOutcome;
typedef std::future<SegmentCommonImageOutcome> SegmentCommonImageOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentCommonImageRequest&, const SegmentCommonImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentCommonImageAsyncHandler;
typedef Outcome<Error, Model::SegmentFaceResult> SegmentFaceOutcome;
typedef std::future<SegmentFaceOutcome> SegmentFaceOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentFaceRequest&, const SegmentFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentFaceAsyncHandler;
typedef Outcome<Error, Model::SegmentFoodResult> SegmentFoodOutcome;
typedef std::future<SegmentFoodOutcome> SegmentFoodOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentFoodRequest&, const SegmentFoodOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentFoodAsyncHandler;
typedef Outcome<Error, Model::SegmentFurnitureResult> SegmentFurnitureOutcome;
typedef std::future<SegmentFurnitureOutcome> SegmentFurnitureOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentFurnitureRequest&, const SegmentFurnitureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentFurnitureAsyncHandler;
typedef Outcome<Error, Model::SegmentHDBodyResult> SegmentHDBodyOutcome;
typedef std::future<SegmentHDBodyOutcome> SegmentHDBodyOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentHDBodyRequest&, const SegmentHDBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentHDBodyAsyncHandler;
typedef Outcome<Error, Model::SegmentHairResult> SegmentHairOutcome;
typedef std::future<SegmentHairOutcome> SegmentHairOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentHairRequest&, const SegmentHairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentHairAsyncHandler;
typedef Outcome<Error, Model::SegmentHeadResult> SegmentHeadOutcome;
typedef std::future<SegmentHeadOutcome> SegmentHeadOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentHeadRequest&, const SegmentHeadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentHeadAsyncHandler;
typedef Outcome<Error, Model::SegmentLogoResult> SegmentLogoOutcome;
typedef std::future<SegmentLogoOutcome> SegmentLogoOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentLogoRequest&, const SegmentLogoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentLogoAsyncHandler;
typedef Outcome<Error, Model::SegmentSceneResult> SegmentSceneOutcome;
typedef std::future<SegmentSceneOutcome> SegmentSceneOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentSceneRequest&, const SegmentSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentSceneAsyncHandler;
typedef Outcome<Error, Model::SegmentSkyResult> SegmentSkyOutcome;
typedef std::future<SegmentSkyOutcome> SegmentSkyOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentSkyRequest&, const SegmentSkyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentSkyAsyncHandler;
typedef Outcome<Error, Model::SegmentVehicleResult> SegmentVehicleOutcome;
typedef std::future<SegmentVehicleOutcome> SegmentVehicleOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentVehicleRequest&, const SegmentVehicleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentVehicleAsyncHandler;
ImagesegClient(const Credentials &credentials, const ClientConfiguration &configuration);
ImagesegClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ImagesegClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ImagesegClient();
ChangeSkyOutcome changeSky(const Model::ChangeSkyRequest &request)const;
void changeSkyAsync(const Model::ChangeSkyRequest& request, const ChangeSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeSkyOutcomeCallable changeSkyCallable(const Model::ChangeSkyRequest& request) const;
GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
ParseFaceOutcome parseFace(const Model::ParseFaceRequest &request)const;
void parseFaceAsync(const Model::ParseFaceRequest& request, const ParseFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ParseFaceOutcomeCallable parseFaceCallable(const Model::ParseFaceRequest& request) const;
RefineMaskOutcome refineMask(const Model::RefineMaskRequest &request)const;
void refineMaskAsync(const Model::RefineMaskRequest& request, const RefineMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RefineMaskOutcomeCallable refineMaskCallable(const Model::RefineMaskRequest& request) const;
SegmentAnimalOutcome segmentAnimal(const Model::SegmentAnimalRequest &request)const;
void segmentAnimalAsync(const Model::SegmentAnimalRequest& request, const SegmentAnimalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentAnimalOutcomeCallable segmentAnimalCallable(const Model::SegmentAnimalRequest& request) const;
SegmentBodyOutcome segmentBody(const Model::SegmentBodyRequest &request)const;
void segmentBodyAsync(const Model::SegmentBodyRequest& request, const SegmentBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentBodyOutcomeCallable segmentBodyCallable(const Model::SegmentBodyRequest& request) const;
SegmentClothOutcome segmentCloth(const Model::SegmentClothRequest &request)const;
void segmentClothAsync(const Model::SegmentClothRequest& request, const SegmentClothAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentClothOutcomeCallable segmentClothCallable(const Model::SegmentClothRequest& request) const;
SegmentCommodityOutcome segmentCommodity(const Model::SegmentCommodityRequest &request)const;
void segmentCommodityAsync(const Model::SegmentCommodityRequest& request, const SegmentCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentCommodityOutcomeCallable segmentCommodityCallable(const Model::SegmentCommodityRequest& request) const;
SegmentCommonImageOutcome segmentCommonImage(const Model::SegmentCommonImageRequest &request)const;
void segmentCommonImageAsync(const Model::SegmentCommonImageRequest& request, const SegmentCommonImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentCommonImageOutcomeCallable segmentCommonImageCallable(const Model::SegmentCommonImageRequest& request) const;
SegmentFaceOutcome segmentFace(const Model::SegmentFaceRequest &request)const;
void segmentFaceAsync(const Model::SegmentFaceRequest& request, const SegmentFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentFaceOutcomeCallable segmentFaceCallable(const Model::SegmentFaceRequest& request) const;
SegmentFoodOutcome segmentFood(const Model::SegmentFoodRequest &request)const;
void segmentFoodAsync(const Model::SegmentFoodRequest& request, const SegmentFoodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentFoodOutcomeCallable segmentFoodCallable(const Model::SegmentFoodRequest& request) const;
SegmentFurnitureOutcome segmentFurniture(const Model::SegmentFurnitureRequest &request)const;
void segmentFurnitureAsync(const Model::SegmentFurnitureRequest& request, const SegmentFurnitureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentFurnitureOutcomeCallable segmentFurnitureCallable(const Model::SegmentFurnitureRequest& request) const;
SegmentHDBodyOutcome segmentHDBody(const Model::SegmentHDBodyRequest &request)const;
void segmentHDBodyAsync(const Model::SegmentHDBodyRequest& request, const SegmentHDBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentHDBodyOutcomeCallable segmentHDBodyCallable(const Model::SegmentHDBodyRequest& request) const;
SegmentHairOutcome segmentHair(const Model::SegmentHairRequest &request)const;
void segmentHairAsync(const Model::SegmentHairRequest& request, const SegmentHairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentHairOutcomeCallable segmentHairCallable(const Model::SegmentHairRequest& request) const;
SegmentHeadOutcome segmentHead(const Model::SegmentHeadRequest &request)const;
void segmentHeadAsync(const Model::SegmentHeadRequest& request, const SegmentHeadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentHeadOutcomeCallable segmentHeadCallable(const Model::SegmentHeadRequest& request) const;
SegmentLogoOutcome segmentLogo(const Model::SegmentLogoRequest &request)const;
void segmentLogoAsync(const Model::SegmentLogoRequest& request, const SegmentLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentLogoOutcomeCallable segmentLogoCallable(const Model::SegmentLogoRequest& request) const;
SegmentSceneOutcome segmentScene(const Model::SegmentSceneRequest &request)const;
void segmentSceneAsync(const Model::SegmentSceneRequest& request, const SegmentSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentSceneOutcomeCallable segmentSceneCallable(const Model::SegmentSceneRequest& request) const;
SegmentSkyOutcome segmentSky(const Model::SegmentSkyRequest &request)const;
void segmentSkyAsync(const Model::SegmentSkyRequest& request, const SegmentSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentSkyOutcomeCallable segmentSkyCallable(const Model::SegmentSkyRequest& request) const;
SegmentVehicleOutcome segmentVehicle(const Model::SegmentVehicleRequest &request)const;
void segmentVehicleAsync(const Model::SegmentVehicleRequest& request, const SegmentVehicleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentVehicleOutcomeCallable segmentVehicleCallable(const Model::SegmentVehicleRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_IMAGESEG_IMAGESEGCLIENT_H_

32
imageseg/include/alibabacloud/imageseg/ImagesegExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_IMAGESEGEXPORT_H_
#define ALIBABACLOUD_IMAGESEG_IMAGESEGEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_IMAGESEG_LIBRARY)
# define ALIBABACLOUD_IMAGESEG_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_IMAGESEG_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_IMAGESEG_EXPORT
#endif
#endif // !ALIBABACLOUD_IMAGESEG_IMAGESEGEXPORT_H_

51
imageseg/include/alibabacloud/imageseg/model/ChangeSkyRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT ChangeSkyRequest : public RpcServiceRequest
{
public:
ChangeSkyRequest();
~ChangeSkyRequest();
std::string getReplaceImageURL()const;
void setReplaceImageURL(const std::string& replaceImageURL);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string replaceImageURL_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/ChangeSkyResult.h Normal file
View File

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

51
imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_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_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_

59
imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTRESULT_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_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_IMAGESEG_MODEL_GETASYNCJOBRESULTRESULT_H_

48
imageseg/include/alibabacloud/imageseg/model/ParseFaceRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT ParseFaceRequest : public RpcServiceRequest
{
public:
ParseFaceRequest();
~ParseFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_

61
imageseg/include/alibabacloud/imageseg/model/ParseFaceResult.h Normal file
View File

@@ -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.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACERESULT_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT ParseFaceResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
std::string imageURL;
std::string name;
};
std::string originImageURL;
std::vector<Element> elements;
};
ParseFaceResult();
explicit ParseFaceResult(const std::string &payload);
~ParseFaceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACERESULT_H_

51
imageseg/include/alibabacloud/imageseg/model/RefineMaskRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT RefineMaskRequest : public RpcServiceRequest
{
public:
RefineMaskRequest();
~RefineMaskRequest();
std::string getMaskImageURL()const;
void setMaskImageURL(const std::string& maskImageURL);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string maskImageURL_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_

59
imageseg/include/alibabacloud/imageseg/model/RefineMaskResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentAnimalRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentAnimalRequest : public RpcServiceRequest
{
public:
SegmentAnimalRequest();
~SegmentAnimalRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentAnimalResult.h Normal file
View File

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

51
imageseg/include/alibabacloud/imageseg/model/SegmentBodyRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentBodyRequest : public RpcServiceRequest
{
public:
SegmentBodyRequest();
~SegmentBodyRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool async_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentBodyResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentClothRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentClothRequest : public RpcServiceRequest
{
public:
SegmentClothRequest();
~SegmentClothRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_

59
imageseg/include/alibabacloud/imageseg/model/SegmentClothResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentCommodityRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommodityRequest : public RpcServiceRequest
{
public:
SegmentCommodityRequest();
~SegmentCommodityRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentCommodityResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommonImageRequest : public RpcServiceRequest
{
public:
SegmentCommonImageRequest();
~SegmentCommonImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentFaceRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFaceRequest : public RpcServiceRequest
{
public:
SegmentFaceRequest();
~SegmentFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_

63
imageseg/include/alibabacloud/imageseg/model/SegmentFaceResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentFoodRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFoodRequest : public RpcServiceRequest
{
public:
SegmentFoodRequest();
~SegmentFoodRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentFoodResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFurnitureRequest : public RpcServiceRequest
{
public:
SegmentFurnitureRequest();
~SegmentFurnitureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_

59
imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDBodyRequest : public RpcServiceRequest
{
public:
SegmentHDBodyRequest();
~SegmentHDBodyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentHairRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHairRequest : public RpcServiceRequest
{
public:
SegmentHairRequest();
~SegmentHairRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_

63
imageseg/include/alibabacloud/imageseg/model/SegmentHairResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentHeadRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHeadRequest : public RpcServiceRequest
{
public:
SegmentHeadRequest();
~SegmentHeadRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_

63
imageseg/include/alibabacloud/imageseg/model/SegmentHeadResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentLogoRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentLogoRequest : public RpcServiceRequest
{
public:
SegmentLogoRequest();
~SegmentLogoRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentLogoResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentSceneRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSceneRequest : public RpcServiceRequest
{
public:
SegmentSceneRequest();
~SegmentSceneRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentSceneResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentSkyRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSkyRequest : public RpcServiceRequest
{
public:
SegmentSkyRequest();
~SegmentSkyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_

55
imageseg/include/alibabacloud/imageseg/model/SegmentSkyResult.h Normal file
View File

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

48
imageseg/include/alibabacloud/imageseg/model/SegmentVehicleRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentVehicleRequest : public RpcServiceRequest
{
public:
SegmentVehicleRequest();
~SegmentVehicleRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_

60
imageseg/include/alibabacloud/imageseg/model/SegmentVehicleResult.h Normal file
View File

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

737
imageseg/src/ImagesegClient.cc Normal file
View File

@@ -0,0 +1,737 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/ImagesegClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
namespace
{
const std::string SERVICE_NAME = "imageseg";
}
ImagesegClient::ImagesegClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
}
ImagesegClient::ImagesegClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
}
ImagesegClient::ImagesegClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
}
ImagesegClient::~ImagesegClient()
{}
ImagesegClient::ChangeSkyOutcome ImagesegClient::changeSky(const ChangeSkyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ChangeSkyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ChangeSkyOutcome(ChangeSkyResult(outcome.result()));
else
return ChangeSkyOutcome(outcome.error());
}
void ImagesegClient::changeSkyAsync(const ChangeSkyRequest& request, const ChangeSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, changeSky(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::ChangeSkyOutcomeCallable ImagesegClient::changeSkyCallable(const ChangeSkyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ChangeSkyOutcome()>>(
[this, request]()
{
return this->changeSky(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::GetAsyncJobResultOutcome ImagesegClient::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 ImagesegClient::getAsyncJobResultAsync(const GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAsyncJobResult(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::GetAsyncJobResultOutcomeCallable ImagesegClient::getAsyncJobResultCallable(const GetAsyncJobResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAsyncJobResultOutcome()>>(
[this, request]()
{
return this->getAsyncJobResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::ParseFaceOutcome ImagesegClient::parseFace(const ParseFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ParseFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ParseFaceOutcome(ParseFaceResult(outcome.result()));
else
return ParseFaceOutcome(outcome.error());
}
void ImagesegClient::parseFaceAsync(const ParseFaceRequest& request, const ParseFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, parseFace(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::ParseFaceOutcomeCallable ImagesegClient::parseFaceCallable(const ParseFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ParseFaceOutcome()>>(
[this, request]()
{
return this->parseFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::RefineMaskOutcome ImagesegClient::refineMask(const RefineMaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RefineMaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RefineMaskOutcome(RefineMaskResult(outcome.result()));
else
return RefineMaskOutcome(outcome.error());
}
void ImagesegClient::refineMaskAsync(const RefineMaskRequest& request, const RefineMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, refineMask(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::RefineMaskOutcomeCallable ImagesegClient::refineMaskCallable(const RefineMaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RefineMaskOutcome()>>(
[this, request]()
{
return this->refineMask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentAnimalOutcome ImagesegClient::segmentAnimal(const SegmentAnimalRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentAnimalOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentAnimalOutcome(SegmentAnimalResult(outcome.result()));
else
return SegmentAnimalOutcome(outcome.error());
}
void ImagesegClient::segmentAnimalAsync(const SegmentAnimalRequest& request, const SegmentAnimalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentAnimal(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentAnimalOutcomeCallable ImagesegClient::segmentAnimalCallable(const SegmentAnimalRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentAnimalOutcome()>>(
[this, request]()
{
return this->segmentAnimal(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentBodyOutcome ImagesegClient::segmentBody(const SegmentBodyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentBodyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentBodyOutcome(SegmentBodyResult(outcome.result()));
else
return SegmentBodyOutcome(outcome.error());
}
void ImagesegClient::segmentBodyAsync(const SegmentBodyRequest& request, const SegmentBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentBody(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentBodyOutcomeCallable ImagesegClient::segmentBodyCallable(const SegmentBodyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentBodyOutcome()>>(
[this, request]()
{
return this->segmentBody(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentClothOutcome ImagesegClient::segmentCloth(const SegmentClothRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentClothOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentClothOutcome(SegmentClothResult(outcome.result()));
else
return SegmentClothOutcome(outcome.error());
}
void ImagesegClient::segmentClothAsync(const SegmentClothRequest& request, const SegmentClothAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentCloth(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentClothOutcomeCallable ImagesegClient::segmentClothCallable(const SegmentClothRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentClothOutcome()>>(
[this, request]()
{
return this->segmentCloth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentCommodityOutcome ImagesegClient::segmentCommodity(const SegmentCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentCommodityOutcome(SegmentCommodityResult(outcome.result()));
else
return SegmentCommodityOutcome(outcome.error());
}
void ImagesegClient::segmentCommodityAsync(const SegmentCommodityRequest& request, const SegmentCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentCommodityOutcomeCallable ImagesegClient::segmentCommodityCallable(const SegmentCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentCommodityOutcome()>>(
[this, request]()
{
return this->segmentCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentCommonImageOutcome ImagesegClient::segmentCommonImage(const SegmentCommonImageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentCommonImageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentCommonImageOutcome(SegmentCommonImageResult(outcome.result()));
else
return SegmentCommonImageOutcome(outcome.error());
}
void ImagesegClient::segmentCommonImageAsync(const SegmentCommonImageRequest& request, const SegmentCommonImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentCommonImage(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentCommonImageOutcomeCallable ImagesegClient::segmentCommonImageCallable(const SegmentCommonImageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentCommonImageOutcome()>>(
[this, request]()
{
return this->segmentCommonImage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentFaceOutcome ImagesegClient::segmentFace(const SegmentFaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentFaceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentFaceOutcome(SegmentFaceResult(outcome.result()));
else
return SegmentFaceOutcome(outcome.error());
}
void ImagesegClient::segmentFaceAsync(const SegmentFaceRequest& request, const SegmentFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentFace(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentFaceOutcomeCallable ImagesegClient::segmentFaceCallable(const SegmentFaceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentFaceOutcome()>>(
[this, request]()
{
return this->segmentFace(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentFoodOutcome ImagesegClient::segmentFood(const SegmentFoodRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentFoodOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentFoodOutcome(SegmentFoodResult(outcome.result()));
else
return SegmentFoodOutcome(outcome.error());
}
void ImagesegClient::segmentFoodAsync(const SegmentFoodRequest& request, const SegmentFoodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentFood(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentFoodOutcomeCallable ImagesegClient::segmentFoodCallable(const SegmentFoodRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentFoodOutcome()>>(
[this, request]()
{
return this->segmentFood(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentFurnitureOutcome ImagesegClient::segmentFurniture(const SegmentFurnitureRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentFurnitureOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentFurnitureOutcome(SegmentFurnitureResult(outcome.result()));
else
return SegmentFurnitureOutcome(outcome.error());
}
void ImagesegClient::segmentFurnitureAsync(const SegmentFurnitureRequest& request, const SegmentFurnitureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentFurniture(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentFurnitureOutcomeCallable ImagesegClient::segmentFurnitureCallable(const SegmentFurnitureRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentFurnitureOutcome()>>(
[this, request]()
{
return this->segmentFurniture(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentHDBodyOutcome ImagesegClient::segmentHDBody(const SegmentHDBodyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentHDBodyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentHDBodyOutcome(SegmentHDBodyResult(outcome.result()));
else
return SegmentHDBodyOutcome(outcome.error());
}
void ImagesegClient::segmentHDBodyAsync(const SegmentHDBodyRequest& request, const SegmentHDBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentHDBody(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentHDBodyOutcomeCallable ImagesegClient::segmentHDBodyCallable(const SegmentHDBodyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentHDBodyOutcome()>>(
[this, request]()
{
return this->segmentHDBody(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentHairOutcome ImagesegClient::segmentHair(const SegmentHairRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentHairOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentHairOutcome(SegmentHairResult(outcome.result()));
else
return SegmentHairOutcome(outcome.error());
}
void ImagesegClient::segmentHairAsync(const SegmentHairRequest& request, const SegmentHairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentHair(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentHairOutcomeCallable ImagesegClient::segmentHairCallable(const SegmentHairRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentHairOutcome()>>(
[this, request]()
{
return this->segmentHair(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentHeadOutcome ImagesegClient::segmentHead(const SegmentHeadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentHeadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentHeadOutcome(SegmentHeadResult(outcome.result()));
else
return SegmentHeadOutcome(outcome.error());
}
void ImagesegClient::segmentHeadAsync(const SegmentHeadRequest& request, const SegmentHeadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentHead(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentHeadOutcomeCallable ImagesegClient::segmentHeadCallable(const SegmentHeadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentHeadOutcome()>>(
[this, request]()
{
return this->segmentHead(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentLogoOutcome ImagesegClient::segmentLogo(const SegmentLogoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentLogoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentLogoOutcome(SegmentLogoResult(outcome.result()));
else
return SegmentLogoOutcome(outcome.error());
}
void ImagesegClient::segmentLogoAsync(const SegmentLogoRequest& request, const SegmentLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentLogo(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentLogoOutcomeCallable ImagesegClient::segmentLogoCallable(const SegmentLogoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentLogoOutcome()>>(
[this, request]()
{
return this->segmentLogo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentSceneOutcome ImagesegClient::segmentScene(const SegmentSceneRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentSceneOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentSceneOutcome(SegmentSceneResult(outcome.result()));
else
return SegmentSceneOutcome(outcome.error());
}
void ImagesegClient::segmentSceneAsync(const SegmentSceneRequest& request, const SegmentSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentScene(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentSceneOutcomeCallable ImagesegClient::segmentSceneCallable(const SegmentSceneRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentSceneOutcome()>>(
[this, request]()
{
return this->segmentScene(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentSkyOutcome ImagesegClient::segmentSky(const SegmentSkyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentSkyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentSkyOutcome(SegmentSkyResult(outcome.result()));
else
return SegmentSkyOutcome(outcome.error());
}
void ImagesegClient::segmentSkyAsync(const SegmentSkyRequest& request, const SegmentSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentSky(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentSkyOutcomeCallable ImagesegClient::segmentSkyCallable(const SegmentSkyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentSkyOutcome()>>(
[this, request]()
{
return this->segmentSky(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentVehicleOutcome ImagesegClient::segmentVehicle(const SegmentVehicleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentVehicleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentVehicleOutcome(SegmentVehicleResult(outcome.result()));
else
return SegmentVehicleOutcome(outcome.error());
}
void ImagesegClient::segmentVehicleAsync(const SegmentVehicleRequest& request, const SegmentVehicleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentVehicle(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentVehicleOutcomeCallable ImagesegClient::segmentVehicleCallable(const SegmentVehicleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentVehicleOutcome()>>(
[this, request]()
{
return this->segmentVehicle(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

51
imageseg/src/model/ChangeSkyRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/ChangeSkyRequest.h>
using AlibabaCloud::Imageseg::Model::ChangeSkyRequest;
ChangeSkyRequest::ChangeSkyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "ChangeSky")
{
setMethod(HttpRequest::Method::Post);
}
ChangeSkyRequest::~ChangeSkyRequest()
{}
std::string ChangeSkyRequest::getReplaceImageURL()const
{
return replaceImageURL_;
}
void ChangeSkyRequest::setReplaceImageURL(const std::string& replaceImageURL)
{
replaceImageURL_ = replaceImageURL;
setParameter("ReplaceImageURL", replaceImageURL);
}
std::string ChangeSkyRequest::getImageURL()const
{
return imageURL_;
}
void ChangeSkyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/ChangeSkyResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/ChangeSkyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
ChangeSkyResult::ChangeSkyResult() :
ServiceResult()
{}
ChangeSkyResult::ChangeSkyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ChangeSkyResult::~ChangeSkyResult()
{}
void ChangeSkyResult::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();
}
ChangeSkyResult::Data ChangeSkyResult::getData()const
{
return data_;
}

51
imageseg/src/model/GetAsyncJobResultRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Imageseg::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("imageseg", "2019-12-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);
}

60
imageseg/src/model/GetAsyncJobResultResult.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/GetAsyncJobResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::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["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
}
GetAsyncJobResultResult::Data GetAsyncJobResultResult::getData()const
{
return data_;
}

40
imageseg/src/model/ParseFaceRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/ParseFaceRequest.h>
using AlibabaCloud::Imageseg::Model::ParseFaceRequest;
ParseFaceRequest::ParseFaceRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "ParseFace")
{
setMethod(HttpRequest::Method::Post);
}
ParseFaceRequest::~ParseFaceRequest()
{}
std::string ParseFaceRequest::getImageURL()const
{
return imageURL_;
}
void ParseFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

62
imageseg/src/model/ParseFaceResult.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/ParseFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
ParseFaceResult::ParseFaceResult() :
ServiceResult()
{}
ParseFaceResult::ParseFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ParseFaceResult::~ParseFaceResult()
{}
void ParseFaceResult::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["OriginImageURL"].isNull())
data_.originImageURL = dataNode["OriginImageURL"].asString();
auto allElementsNode = dataNode["Elements"]["Element"];
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Name"].isNull())
elementObject.name = dataNodeElementsElement["Name"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
data_.elements.push_back(elementObject);
}
}
ParseFaceResult::Data ParseFaceResult::getData()const
{
return data_;
}

51
imageseg/src/model/RefineMaskRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/RefineMaskRequest.h>
using AlibabaCloud::Imageseg::Model::RefineMaskRequest;
RefineMaskRequest::RefineMaskRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "RefineMask")
{
setMethod(HttpRequest::Method::Post);
}
RefineMaskRequest::~RefineMaskRequest()
{}
std::string RefineMaskRequest::getMaskImageURL()const
{
return maskImageURL_;
}
void RefineMaskRequest::setMaskImageURL(const std::string& maskImageURL)
{
maskImageURL_ = maskImageURL;
setBodyParameter("MaskImageURL", maskImageURL);
}
std::string RefineMaskRequest::getImageURL()const
{
return imageURL_;
}
void RefineMaskRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

58
imageseg/src/model/RefineMaskResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/RefineMaskResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
RefineMaskResult::RefineMaskResult() :
ServiceResult()
{}
RefineMaskResult::RefineMaskResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RefineMaskResult::~RefineMaskResult()
{}
void RefineMaskResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
data_.elements.push_back(elementObject);
}
}
RefineMaskResult::Data RefineMaskResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentAnimalRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentAnimalRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentAnimalRequest;
SegmentAnimalRequest::SegmentAnimalRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentAnimal")
{
setMethod(HttpRequest::Method::Post);
}
SegmentAnimalRequest::~SegmentAnimalRequest()
{}
std::string SegmentAnimalRequest::getImageURL()const
{
return imageURL_;
}
void SegmentAnimalRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentAnimalResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentAnimalResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentAnimalResult::SegmentAnimalResult() :
ServiceResult()
{}
SegmentAnimalResult::SegmentAnimalResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentAnimalResult::~SegmentAnimalResult()
{}
void SegmentAnimalResult::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();
}
SegmentAnimalResult::Data SegmentAnimalResult::getData()const
{
return data_;
}

51
imageseg/src/model/SegmentBodyRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentBodyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentBodyRequest;
SegmentBodyRequest::SegmentBodyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentBody")
{
setMethod(HttpRequest::Method::Post);
}
SegmentBodyRequest::~SegmentBodyRequest()
{}
bool SegmentBodyRequest::getAsync()const
{
return async_;
}
void SegmentBodyRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string SegmentBodyRequest::getImageURL()const
{
return imageURL_;
}
void SegmentBodyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentBodyResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentBodyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentBodyResult::SegmentBodyResult() :
ServiceResult()
{}
SegmentBodyResult::SegmentBodyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentBodyResult::~SegmentBodyResult()
{}
void SegmentBodyResult::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();
}
SegmentBodyResult::Data SegmentBodyResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentClothRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentClothRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentClothRequest;
SegmentClothRequest::SegmentClothRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentCloth")
{
setMethod(HttpRequest::Method::Post);
}
SegmentClothRequest::~SegmentClothRequest()
{}
std::string SegmentClothRequest::getImageURL()const
{
return imageURL_;
}
void SegmentClothRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

58
imageseg/src/model/SegmentClothResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentClothResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentClothResult::SegmentClothResult() :
ServiceResult()
{}
SegmentClothResult::SegmentClothResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentClothResult::~SegmentClothResult()
{}
void SegmentClothResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
data_.elements.push_back(elementObject);
}
}
SegmentClothResult::Data SegmentClothResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentCommodityRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentCommodityRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommodityRequest;
SegmentCommodityRequest::SegmentCommodityRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommodity")
{
setMethod(HttpRequest::Method::Post);
}
SegmentCommodityRequest::~SegmentCommodityRequest()
{}
std::string SegmentCommodityRequest::getImageURL()const
{
return imageURL_;
}
void SegmentCommodityRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentCommodityResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentCommodityResult::SegmentCommodityResult() :
ServiceResult()
{}
SegmentCommodityResult::SegmentCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentCommodityResult::~SegmentCommodityResult()
{}
void SegmentCommodityResult::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();
}
SegmentCommodityResult::Data SegmentCommodityResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentCommonImageRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommonImageRequest;
SegmentCommonImageRequest::SegmentCommonImageRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommonImage")
{
setMethod(HttpRequest::Method::Post);
}
SegmentCommonImageRequest::~SegmentCommonImageRequest()
{}
std::string SegmentCommonImageRequest::getImageURL()const
{
return imageURL_;
}
void SegmentCommonImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentCommonImageResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentCommonImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentCommonImageResult::SegmentCommonImageResult() :
ServiceResult()
{}
SegmentCommonImageResult::SegmentCommonImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentCommonImageResult::~SegmentCommonImageResult()
{}
void SegmentCommonImageResult::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();
}
SegmentCommonImageResult::Data SegmentCommonImageResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentFaceRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentFaceRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentFaceRequest;
SegmentFaceRequest::SegmentFaceRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentFace")
{
setMethod(HttpRequest::Method::Post);
}
SegmentFaceRequest::~SegmentFaceRequest()
{}
std::string SegmentFaceRequest::getImageURL()const
{
return imageURL_;
}
void SegmentFaceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

66
imageseg/src/model/SegmentFaceResult.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentFaceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentFaceResult::SegmentFaceResult() :
ServiceResult()
{}
SegmentFaceResult::SegmentFaceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentFaceResult::~SegmentFaceResult()
{}
void SegmentFaceResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
data_.elements.push_back(elementObject);
}
}
SegmentFaceResult::Data SegmentFaceResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentFoodRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentFoodRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentFoodRequest;
SegmentFoodRequest::SegmentFoodRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentFood")
{
setMethod(HttpRequest::Method::Post);
}
SegmentFoodRequest::~SegmentFoodRequest()
{}
std::string SegmentFoodRequest::getImageURL()const
{
return imageURL_;
}
void SegmentFoodRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentFoodResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentFoodResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentFoodResult::SegmentFoodResult() :
ServiceResult()
{}
SegmentFoodResult::SegmentFoodResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentFoodResult::~SegmentFoodResult()
{}
void SegmentFoodResult::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();
}
SegmentFoodResult::Data SegmentFoodResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentFurnitureRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentFurnitureRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentFurnitureRequest;
SegmentFurnitureRequest::SegmentFurnitureRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentFurniture")
{
setMethod(HttpRequest::Method::Post);
}
SegmentFurnitureRequest::~SegmentFurnitureRequest()
{}
std::string SegmentFurnitureRequest::getImageURL()const
{
return imageURL_;
}
void SegmentFurnitureRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

58
imageseg/src/model/SegmentFurnitureResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentFurnitureResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentFurnitureResult::SegmentFurnitureResult() :
ServiceResult()
{}
SegmentFurnitureResult::SegmentFurnitureResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentFurnitureResult::~SegmentFurnitureResult()
{}
void SegmentFurnitureResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
data_.elements.push_back(elementObject);
}
}
SegmentFurnitureResult::Data SegmentFurnitureResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentHDBodyRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentHDBodyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHDBodyRequest;
SegmentHDBodyRequest::SegmentHDBodyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHDBody")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHDBodyRequest::~SegmentHDBodyRequest()
{}
std::string SegmentHDBodyRequest::getImageURL()const
{
return imageURL_;
}
void SegmentHDBodyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentHDBodyResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentHDBodyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentHDBodyResult::SegmentHDBodyResult() :
ServiceResult()
{}
SegmentHDBodyResult::SegmentHDBodyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentHDBodyResult::~SegmentHDBodyResult()
{}
void SegmentHDBodyResult::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();
}
SegmentHDBodyResult::Data SegmentHDBodyResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentHairRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentHairRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHairRequest;
SegmentHairRequest::SegmentHairRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHair")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHairRequest::~SegmentHairRequest()
{}
std::string SegmentHairRequest::getImageURL()const
{
return imageURL_;
}
void SegmentHairRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

66
imageseg/src/model/SegmentHairResult.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentHairResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentHairResult::SegmentHairResult() :
ServiceResult()
{}
SegmentHairResult::SegmentHairResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentHairResult::~SegmentHairResult()
{}
void SegmentHairResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
data_.elements.push_back(elementObject);
}
}
SegmentHairResult::Data SegmentHairResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentHeadRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentHeadRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHeadRequest;
SegmentHeadRequest::SegmentHeadRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHead")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHeadRequest::~SegmentHeadRequest()
{}
std::string SegmentHeadRequest::getImageURL()const
{
return imageURL_;
}
void SegmentHeadRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

66
imageseg/src/model/SegmentHeadResult.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentHeadResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentHeadResult::SegmentHeadResult() :
ServiceResult()
{}
SegmentHeadResult::SegmentHeadResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentHeadResult::~SegmentHeadResult()
{}
void SegmentHeadResult::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["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
data_.elements.push_back(elementObject);
}
}
SegmentHeadResult::Data SegmentHeadResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentLogoRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentLogoRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentLogoRequest;
SegmentLogoRequest::SegmentLogoRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentLogo")
{
setMethod(HttpRequest::Method::Post);
}
SegmentLogoRequest::~SegmentLogoRequest()
{}
std::string SegmentLogoRequest::getImageURL()const
{
return imageURL_;
}
void SegmentLogoRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentLogoResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentLogoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentLogoResult::SegmentLogoResult() :
ServiceResult()
{}
SegmentLogoResult::SegmentLogoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentLogoResult::~SegmentLogoResult()
{}
void SegmentLogoResult::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();
}
SegmentLogoResult::Data SegmentLogoResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentSceneRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentSceneRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentSceneRequest;
SegmentSceneRequest::SegmentSceneRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentScene")
{
setMethod(HttpRequest::Method::Post);
}
SegmentSceneRequest::~SegmentSceneRequest()
{}
std::string SegmentSceneRequest::getImageURL()const
{
return imageURL_;
}
void SegmentSceneRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentSceneResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentSceneResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentSceneResult::SegmentSceneResult() :
ServiceResult()
{}
SegmentSceneResult::SegmentSceneResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentSceneResult::~SegmentSceneResult()
{}
void SegmentSceneResult::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();
}
SegmentSceneResult::Data SegmentSceneResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentSkyRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentSkyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentSkyRequest;
SegmentSkyRequest::SegmentSkyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentSky")
{
setMethod(HttpRequest::Method::Post);
}
SegmentSkyRequest::~SegmentSkyRequest()
{}
std::string SegmentSkyRequest::getImageURL()const
{
return imageURL_;
}
void SegmentSkyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}

52
imageseg/src/model/SegmentSkyResult.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentSkyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentSkyResult::SegmentSkyResult() :
ServiceResult()
{}
SegmentSkyResult::SegmentSkyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentSkyResult::~SegmentSkyResult()
{}
void SegmentSkyResult::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();
}
SegmentSkyResult::Data SegmentSkyResult::getData()const
{
return data_;
}

40
imageseg/src/model/SegmentVehicleRequest.cc Normal file
View File

@@ -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 <alibabacloud/imageseg/model/SegmentVehicleRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentVehicleRequest;
SegmentVehicleRequest::SegmentVehicleRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentVehicle")
{
setMethod(HttpRequest::Method::Post);
}
SegmentVehicleRequest::~SegmentVehicleRequest()
{}
std::string SegmentVehicleRequest::getImageURL()const
{
return imageURL_;
}
void SegmentVehicleRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

60
imageseg/src/model/SegmentVehicleResult.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentVehicleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentVehicleResult::SegmentVehicleResult() :
ServiceResult()
{}
SegmentVehicleResult::SegmentVehicleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentVehicleResult::~SegmentVehicleResult()
{}
void SegmentVehicleResult::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["OriginImageURL"].isNull())
elementObject.originImageURL = dataNodeElementsElement["OriginImageURL"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
data_.elements.push_back(elementObject);
}
}
SegmentVehicleResult::Data SegmentVehicleResult::getData()const
{
return data_;
}