Release ChangeSky.

CHANGELOG

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

imageseg/CMakeLists.txt

@@ -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}
+	)

imageseg/include/alibabacloud/imageseg/ImagesegClient.h

@@ -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_

imageseg/include/alibabacloud/imageseg/ImagesegExport.h

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

imageseg/include/alibabacloud/imageseg/model/ChangeSkyRequest.h

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

imageseg/include/alibabacloud/imageseg/model/ChangeSkyResult.h

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

imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultRequest.h

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

imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultResult.h

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

imageseg/include/alibabacloud/imageseg/model/ParseFaceRequest.h

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

imageseg/include/alibabacloud/imageseg/model/ParseFaceResult.h

@@ -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_

imageseg/include/alibabacloud/imageseg/model/RefineMaskRequest.h

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

imageseg/include/alibabacloud/imageseg/model/RefineMaskResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentAnimalRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentAnimalResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentBodyRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentBodyResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentClothRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentClothResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentCommodityRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentCommodityResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFaceRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFaceResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFoodRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFoodResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHairRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHairResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHeadRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentHeadResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentLogoRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentLogoResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentSceneRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentSceneResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentSkyRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentSkyResult.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentVehicleRequest.h

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

imageseg/include/alibabacloud/imageseg/model/SegmentVehicleResult.h

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

imageseg/src/ImagesegClient.cc

@@ -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();
+}
+

imageseg/src/model/ChangeSkyRequest.cc

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

imageseg/src/model/ChangeSkyResult.cc

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

imageseg/src/model/GetAsyncJobResultRequest.cc

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

imageseg/src/model/GetAsyncJobResultResult.cc

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

imageseg/src/model/ParseFaceRequest.cc

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

imageseg/src/model/ParseFaceResult.cc

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

imageseg/src/model/RefineMaskRequest.cc

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

imageseg/src/model/RefineMaskResult.cc

@@ -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_;
+}
+

imageseg/src/model/SegmentAnimalRequest.cc

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

imageseg/src/model/SegmentAnimalResult.cc

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

imageseg/src/model/SegmentBodyRequest.cc

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

imageseg/src/model/SegmentBodyResult.cc

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

imageseg/src/model/SegmentClothRequest.cc

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

imageseg/src/model/SegmentClothResult.cc

@@ -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_;
+}
+

imageseg/src/model/SegmentCommodityRequest.cc

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

imageseg/src/model/SegmentCommodityResult.cc

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

imageseg/src/model/SegmentCommonImageRequest.cc

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

imageseg/src/model/SegmentCommonImageResult.cc

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

imageseg/src/model/SegmentFaceRequest.cc

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

imageseg/src/model/SegmentFaceResult.cc

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

imageseg/src/model/SegmentFoodRequest.cc

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

imageseg/src/model/SegmentFoodResult.cc

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

imageseg/src/model/SegmentFurnitureRequest.cc

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

imageseg/src/model/SegmentFurnitureResult.cc

@@ -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_;
+}
+

imageseg/src/model/SegmentHDBodyRequest.cc

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

imageseg/src/model/SegmentHDBodyResult.cc

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

imageseg/src/model/SegmentHairRequest.cc

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

imageseg/src/model/SegmentHairResult.cc

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

imageseg/src/model/SegmentHeadRequest.cc

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

imageseg/src/model/SegmentHeadResult.cc

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

imageseg/src/model/SegmentLogoRequest.cc

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

imageseg/src/model/SegmentLogoResult.cc

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

imageseg/src/model/SegmentSceneRequest.cc

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

imageseg/src/model/SegmentSceneResult.cc

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

imageseg/src/model/SegmentSkyRequest.cc

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

imageseg/src/model/SegmentSkyResult.cc

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

imageseg/src/model/SegmentVehicleRequest.cc

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

imageseg/src/model/SegmentVehicleResult.cc

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