code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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/SegmentHDCommonImageRequest.h
include/alibabacloud/imageseg/model/SegmentHDCommonImageResult.h
include/alibabacloud/imageseg/model/SegmentHDSkyRequest.h
include/alibabacloud/imageseg/model/SegmentHDSkyResult.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/SegmentSkinRequest.h
include/alibabacloud/imageseg/model/SegmentSkinResult.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/SegmentHDCommonImageRequest.cc
src/model/SegmentHDCommonImageResult.cc
src/model/SegmentHDSkyRequest.cc
src/model/SegmentHDSkyResult.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/SegmentSkinRequest.cc
src/model/SegmentSkinResult.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}
)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/CMakeLists.txt
|
CMake
|
apache-2.0
| 6,527
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentHDCommonImageRequest.h"
#include "model/SegmentHDCommonImageResult.h"
#include "model/SegmentHDSkyRequest.h"
#include "model/SegmentHDSkyResult.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/SegmentSkinRequest.h"
#include "model/SegmentSkinResult.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::SegmentHDCommonImageResult> SegmentHDCommonImageOutcome;
typedef std::future<SegmentHDCommonImageOutcome> SegmentHDCommonImageOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentHDCommonImageRequest&, const SegmentHDCommonImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentHDCommonImageAsyncHandler;
typedef Outcome<Error, Model::SegmentHDSkyResult> SegmentHDSkyOutcome;
typedef std::future<SegmentHDSkyOutcome> SegmentHDSkyOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentHDSkyRequest&, const SegmentHDSkyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentHDSkyAsyncHandler;
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::SegmentSkinResult> SegmentSkinOutcome;
typedef std::future<SegmentSkinOutcome> SegmentSkinOutcomeCallable;
typedef std::function<void(const ImagesegClient*, const Model::SegmentSkinRequest&, const SegmentSkinOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SegmentSkinAsyncHandler;
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;
SegmentHDCommonImageOutcome segmentHDCommonImage(const Model::SegmentHDCommonImageRequest &request)const;
void segmentHDCommonImageAsync(const Model::SegmentHDCommonImageRequest& request, const SegmentHDCommonImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentHDCommonImageOutcomeCallable segmentHDCommonImageCallable(const Model::SegmentHDCommonImageRequest& request) const;
SegmentHDSkyOutcome segmentHDSky(const Model::SegmentHDSkyRequest &request)const;
void segmentHDSkyAsync(const Model::SegmentHDSkyRequest& request, const SegmentHDSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentHDSkyOutcomeCallable segmentHDSkyCallable(const Model::SegmentHDSkyRequest& 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;
SegmentSkinOutcome segmentSkin(const Model::SegmentSkinRequest &request)const;
void segmentSkinAsync(const Model::SegmentSkinRequest& request, const SegmentSkinAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SegmentSkinOutcomeCallable segmentSkinCallable(const Model::SegmentSkinRequest& 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/ImagesegClient.h
|
C++
|
apache-2.0
| 19,259
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/ImagesegExport.h
|
C
|
apache-2.0
| 1,086
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/ChangeSkyRequest.h
|
C++
|
apache-2.0
| 1,454
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/ChangeSkyResult.h
|
C++
|
apache-2.0
| 1,401
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultRequest.h
|
C++
|
apache-2.0
| 1,422
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultResult.h
|
C++
|
apache-2.0
| 1,563
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/ParseFaceRequest.h
|
C++
|
apache-2.0
| 1,309
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/ParseFaceResult.h
|
C++
|
apache-2.0
| 1,530
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/RefineMaskRequest.h
|
C++
|
apache-2.0
| 1,448
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/RefineMaskResult.h
|
C++
|
apache-2.0
| 1,480
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentAnimalRequest.h
|
C++
|
apache-2.0
| 1,333
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentAnimalResult.h
|
C++
|
apache-2.0
| 1,429
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
bool getAsync()const;
void setAsync(bool async);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
bool async_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentBodyRequest.h
|
C++
|
apache-2.0
| 1,523
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentBodyResult.h
|
C++
|
apache-2.0
| 1,415
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentClothRequest.h
|
C++
|
apache-2.0
| 1,327
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentClothResult.h
|
C++
|
apache-2.0
| 1,494
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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 getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentCommodityRequest.h
|
C++
|
apache-2.0
| 1,476
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentCommodityResult.h
|
C++
|
apache-2.0
| 1,450
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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 getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageRequest.h
|
C++
|
apache-2.0
| 1,482
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageResult.h
|
C++
|
apache-2.0
| 1,464
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFaceRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFaceResult.h
|
C++
|
apache-2.0
| 1,548
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFoodRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFoodResult.h
|
C++
|
apache-2.0
| 1,415
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureRequest.h
|
C++
|
apache-2.0
| 1,351
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureResult.h
|
C++
|
apache-2.0
| 1,522
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyRequest.h
|
C++
|
apache-2.0
| 1,333
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyResult.h
|
C++
|
apache-2.0
| 1,429
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTHDCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_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 SegmentHDCommonImageRequest : public RpcServiceRequest
{
public:
SegmentHDCommonImageRequest();
~SegmentHDCommonImageRequest();
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_SEGMENTHDCOMMONIMAGEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDCommonImageRequest.h
|
C++
|
apache-2.0
| 1,452
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTHDCOMMONIMAGERESULT_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGERESULT_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 SegmentHDCommonImageResult : public ServiceResult
{
public:
struct Data
{
std::string imageUrl;
};
SegmentHDCommonImageResult();
explicit SegmentHDCommonImageResult(const std::string &payload);
~SegmentHDCommonImageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDCommonImageResult.h
|
C++
|
apache-2.0
| 1,478
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTHDSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_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 SegmentHDSkyRequest : public RpcServiceRequest
{
public:
SegmentHDSkyRequest();
~SegmentHDSkyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDSkyRequest.h
|
C++
|
apache-2.0
| 1,327
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTHDSKYRESULT_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYRESULT_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 SegmentHDSkyResult : public ServiceResult
{
public:
struct Data
{
std::string imageURL;
};
SegmentHDSkyResult();
explicit SegmentHDSkyResult(const std::string &payload);
~SegmentHDSkyResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHDSkyResult.h
|
C++
|
apache-2.0
| 1,422
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHairRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHairResult.h
|
C++
|
apache-2.0
| 1,548
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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 getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHeadRequest.h
|
C++
|
apache-2.0
| 1,440
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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;
int y;
std::string imageURL;
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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentHeadResult.h
|
C++
|
apache-2.0
| 1,548
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentLogoRequest.h
|
C++
|
apache-2.0
| 1,321
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentLogoResult.h
|
C++
|
apache-2.0
| 1,415
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSceneRequest.h
|
C++
|
apache-2.0
| 1,327
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSceneResult.h
|
C++
|
apache-2.0
| 1,422
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTSKINREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_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 SegmentSkinRequest : public RpcServiceRequest
{
public:
SegmentSkinRequest();
~SegmentSkinRequest();
std::string getURL()const;
void setURL(const std::string& uRL);
private:
std::string uRL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSkinRequest.h
|
C++
|
apache-2.0
| 1,301
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_SEGMENTSKINRESULT_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINRESULT_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 SegmentSkinResult : public ServiceResult
{
public:
struct Data
{
std::string uRL;
};
SegmentSkinResult();
explicit SegmentSkinResult(const std::string &payload);
~SegmentSkinResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSkinResult.h
|
C++
|
apache-2.0
| 1,410
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSkyRequest.h
|
C++
|
apache-2.0
| 1,315
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentSkyResult.h
|
C++
|
apache-2.0
| 1,408
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentVehicleRequest.h
|
C++
|
apache-2.0
| 1,339
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/include/alibabacloud/imageseg/model/SegmentVehicleResult.h
|
C++
|
apache-2.0
| 1,542
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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::SegmentHDCommonImageOutcome ImagesegClient::segmentHDCommonImage(const SegmentHDCommonImageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentHDCommonImageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentHDCommonImageOutcome(SegmentHDCommonImageResult(outcome.result()));
else
return SegmentHDCommonImageOutcome(outcome.error());
}
void ImagesegClient::segmentHDCommonImageAsync(const SegmentHDCommonImageRequest& request, const SegmentHDCommonImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentHDCommonImage(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentHDCommonImageOutcomeCallable ImagesegClient::segmentHDCommonImageCallable(const SegmentHDCommonImageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentHDCommonImageOutcome()>>(
[this, request]()
{
return this->segmentHDCommonImage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ImagesegClient::SegmentHDSkyOutcome ImagesegClient::segmentHDSky(const SegmentHDSkyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentHDSkyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentHDSkyOutcome(SegmentHDSkyResult(outcome.result()));
else
return SegmentHDSkyOutcome(outcome.error());
}
void ImagesegClient::segmentHDSkyAsync(const SegmentHDSkyRequest& request, const SegmentHDSkyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentHDSky(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentHDSkyOutcomeCallable ImagesegClient::segmentHDSkyCallable(const SegmentHDSkyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentHDSkyOutcome()>>(
[this, request]()
{
return this->segmentHDSky(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::SegmentSkinOutcome ImagesegClient::segmentSkin(const SegmentSkinRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SegmentSkinOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SegmentSkinOutcome(SegmentSkinResult(outcome.result()));
else
return SegmentSkinOutcome(outcome.error());
}
void ImagesegClient::segmentSkinAsync(const SegmentSkinRequest& request, const SegmentSkinAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, segmentSkin(request), context);
};
asyncExecute(new Runnable(fn));
}
ImagesegClient::SegmentSkinOutcomeCallable ImagesegClient::segmentSkinCallable(const SegmentSkinRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SegmentSkinOutcome()>>(
[this, request]()
{
return this->segmentSkin(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();
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/ImagesegClient.cc
|
C++
|
apache-2.0
| 28,118
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/ChangeSkyRequest.cc
|
C++
|
apache-2.0
| 1,410
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/ChangeSkyResult.cc
|
C++
|
apache-2.0
| 1,372
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/GetAsyncJobResultRequest.cc
|
C++
|
apache-2.0
| 1,400
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/GetAsyncJobResultResult.cc
|
C++
|
apache-2.0
| 1,798
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/ParseFaceRequest.cc
|
C++
|
apache-2.0
| 1,141
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/ParseFaceResult.cc
|
C++
|
apache-2.0
| 1,825
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/RefineMaskRequest.cc
|
C++
|
apache-2.0
| 1,405
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/RefineMaskResult.cc
|
C++
|
apache-2.0
| 1,613
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentAnimalRequest.cc
|
C++
|
apache-2.0
| 1,177
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentAnimalResult.cc
|
C++
|
apache-2.0
| 1,412
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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()
{}
std::string SegmentBodyRequest::getReturnForm()const
{
return returnForm_;
}
void SegmentBodyRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
}
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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentBodyRequest.cc
|
C++
|
apache-2.0
| 1,587
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentBodyResult.cc
|
C++
|
apache-2.0
| 1,392
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentClothRequest.cc
|
C++
|
apache-2.0
| 1,168
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentClothResult.cc
|
C++
|
apache-2.0
| 1,633
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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::getReturnForm()const
{
return returnForm_;
}
void SegmentCommodityRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
}
std::string SegmentCommodityRequest::getImageURL()const
{
return imageURL_;
}
void SegmentCommodityRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentCommodityRequest.cc
|
C++
|
apache-2.0
| 1,447
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentCommodityResult.cc
|
C++
|
apache-2.0
| 1,442
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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::getReturnForm()const
{
return returnForm_;
}
void SegmentCommonImageRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
}
std::string SegmentCommonImageRequest::getImageURL()const
{
return imageURL_;
}
void SegmentCommonImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentCommonImageRequest.cc
|
C++
|
apache-2.0
| 1,445
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentCommonImageResult.cc
|
C++
|
apache-2.0
| 1,462
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFaceRequest.cc
|
C++
|
apache-2.0
| 1,159
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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"];
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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFaceResult.cc
|
C++
|
apache-2.0
| 2,111
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFoodRequest.cc
|
C++
|
apache-2.0
| 1,159
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFoodResult.cc
|
C++
|
apache-2.0
| 1,392
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFurnitureRequest.cc
|
C++
|
apache-2.0
| 1,208
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentFurnitureResult.cc
|
C++
|
apache-2.0
| 1,673
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDBodyRequest.cc
|
C++
|
apache-2.0
| 1,177
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDBodyResult.cc
|
C++
|
apache-2.0
| 1,412
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentHDCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHDCommonImageRequest;
SegmentHDCommonImageRequest::SegmentHDCommonImageRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHDCommonImage")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHDCommonImageRequest::~SegmentHDCommonImageRequest()
{}
bool SegmentHDCommonImageRequest::getAsync()const
{
return async_;
}
void SegmentHDCommonImageRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string SegmentHDCommonImageRequest::getImageUrl()const
{
return imageUrl_;
}
void SegmentHDCommonImageRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDCommonImageRequest.cc
|
C++
|
apache-2.0
| 1,457
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentHDCommonImageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentHDCommonImageResult::SegmentHDCommonImageResult() :
ServiceResult()
{}
SegmentHDCommonImageResult::SegmentHDCommonImageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentHDCommonImageResult::~SegmentHDCommonImageResult()
{}
void SegmentHDCommonImageResult::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();
}
SegmentHDCommonImageResult::Data SegmentHDCommonImageResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDCommonImageResult.cc
|
C++
|
apache-2.0
| 1,482
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentHDSkyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHDSkyRequest;
SegmentHDSkyRequest::SegmentHDSkyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHDSky")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHDSkyRequest::~SegmentHDSkyRequest()
{}
std::string SegmentHDSkyRequest::getImageURL()const
{
return imageURL_;
}
void SegmentHDSkyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDSkyRequest.cc
|
C++
|
apache-2.0
| 1,172
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentHDSkyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentHDSkyResult::SegmentHDSkyResult() :
ServiceResult()
{}
SegmentHDSkyResult::SegmentHDSkyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentHDSkyResult::~SegmentHDSkyResult()
{}
void SegmentHDSkyResult::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();
}
SegmentHDSkyResult::Data SegmentHDSkyResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHDSkyResult.cc
|
C++
|
apache-2.0
| 1,402
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHairRequest.cc
|
C++
|
apache-2.0
| 1,159
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHairResult.cc
|
C++
|
apache-2.0
| 2,122
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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::getReturnForm()const
{
return returnForm_;
}
void SegmentHeadRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
}
std::string SegmentHeadRequest::getImageURL()const
{
return imageURL_;
}
void SegmentHeadRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHeadRequest.cc
|
C++
|
apache-2.0
| 1,392
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
data_.elements.push_back(elementObject);
}
}
SegmentHeadResult::Data SegmentHeadResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentHeadResult.cc
|
C++
|
apache-2.0
| 2,122
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentLogoRequest.cc
|
C++
|
apache-2.0
| 1,159
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentLogoResult.cc
|
C++
|
apache-2.0
| 1,392
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSceneRequest.cc
|
C++
|
apache-2.0
| 1,168
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSceneResult.cc
|
C++
|
apache-2.0
| 1,402
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentSkinRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentSkinRequest;
SegmentSkinRequest::SegmentSkinRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentSkin")
{
setMethod(HttpRequest::Method::Post);
}
SegmentSkinRequest::~SegmentSkinRequest()
{}
std::string SegmentSkinRequest::getURL()const
{
return uRL_;
}
void SegmentSkinRequest::setURL(const std::string& uRL)
{
uRL_ = uRL;
setBodyParameter("URL", uRL);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSkinRequest.cc
|
C++
|
apache-2.0
| 1,123
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/SegmentSkinResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Imageseg;
using namespace AlibabaCloud::Imageseg::Model;
SegmentSkinResult::SegmentSkinResult() :
ServiceResult()
{}
SegmentSkinResult::SegmentSkinResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SegmentSkinResult::~SegmentSkinResult()
{}
void SegmentSkinResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["URL"].isNull())
data_.uRL = dataNode["URL"].asString();
}
SegmentSkinResult::Data SegmentSkinResult::getData()const
{
return data_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSkinResult.cc
|
C++
|
apache-2.0
| 1,377
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSkyRequest.cc
|
C++
|
apache-2.0
| 1,150
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentSkyResult.cc
|
C++
|
apache-2.0
| 1,382
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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);
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentVehicleRequest.cc
|
C++
|
apache-2.0
| 1,190
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_;
}
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/imageseg/src/model/SegmentVehicleResult.cc
|
C++
|
apache-2.0
| 1,799
|
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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(objectdet_public_header
include/alibabacloud/objectdet/ObjectdetClient.h
include/alibabacloud/objectdet/ObjectdetExport.h )
set(objectdet_public_header_model
include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h
include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceResult.h
include/alibabacloud/objectdet/model/DetectMainBodyRequest.h
include/alibabacloud/objectdet/model/DetectMainBodyResult.h
include/alibabacloud/objectdet/model/DetectObjectRequest.h
include/alibabacloud/objectdet/model/DetectObjectResult.h
include/alibabacloud/objectdet/model/DetectTransparentImageRequest.h
include/alibabacloud/objectdet/model/DetectTransparentImageResult.h
include/alibabacloud/objectdet/model/DetectVehicleRequest.h
include/alibabacloud/objectdet/model/DetectVehicleResult.h
include/alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h
include/alibabacloud/objectdet/model/DetectWhiteBaseImageResult.h
include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h
include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanResult.h
include/alibabacloud/objectdet/model/GetVehicleRepairPlanRequest.h
include/alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h
include/alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h
include/alibabacloud/objectdet/model/RecognizeVehicleDamageResult.h
include/alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h
include/alibabacloud/objectdet/model/RecognizeVehicleDashboardResult.h
include/alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h
include/alibabacloud/objectdet/model/RecognizeVehiclePartsResult.h )
set(objectdet_src
src/ObjectdetClient.cc
src/model/ClassifyVehicleInsuranceRequest.cc
src/model/ClassifyVehicleInsuranceResult.cc
src/model/DetectMainBodyRequest.cc
src/model/DetectMainBodyResult.cc
src/model/DetectObjectRequest.cc
src/model/DetectObjectResult.cc
src/model/DetectTransparentImageRequest.cc
src/model/DetectTransparentImageResult.cc
src/model/DetectVehicleRequest.cc
src/model/DetectVehicleResult.cc
src/model/DetectWhiteBaseImageRequest.cc
src/model/DetectWhiteBaseImageResult.cc
src/model/GenerateVehicleRepairPlanRequest.cc
src/model/GenerateVehicleRepairPlanResult.cc
src/model/GetVehicleRepairPlanRequest.cc
src/model/GetVehicleRepairPlanResult.cc
src/model/RecognizeVehicleDamageRequest.cc
src/model/RecognizeVehicleDamageResult.cc
src/model/RecognizeVehicleDashboardRequest.cc
src/model/RecognizeVehicleDashboardResult.cc
src/model/RecognizeVehiclePartsRequest.cc
src/model/RecognizeVehiclePartsResult.cc )
add_library(objectdet ${LIB_TYPE}
${objectdet_public_header}
${objectdet_public_header_model}
${objectdet_src})
set_target_properties(objectdet
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}objectdet
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(objectdet
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_OBJECTDET_LIBRARY)
endif()
target_include_directories(objectdet
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(objectdet
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(objectdet
jsoncpp)
target_include_directories(objectdet
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(objectdet
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(objectdet
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(objectdet
PRIVATE /usr/include/jsoncpp)
target_link_libraries(objectdet
jsoncpp)
endif()
install(FILES ${objectdet_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/objectdet)
install(FILES ${objectdet_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/objectdet/model)
install(TARGETS objectdet
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/CMakeLists.txt
|
CMake
|
apache-2.0
| 4,842
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_OBJECTDETCLIENT_H_
#define ALIBABACLOUD_OBJECTDET_OBJECTDETCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ObjectdetExport.h"
#include "model/ClassifyVehicleInsuranceRequest.h"
#include "model/ClassifyVehicleInsuranceResult.h"
#include "model/DetectMainBodyRequest.h"
#include "model/DetectMainBodyResult.h"
#include "model/DetectObjectRequest.h"
#include "model/DetectObjectResult.h"
#include "model/DetectTransparentImageRequest.h"
#include "model/DetectTransparentImageResult.h"
#include "model/DetectVehicleRequest.h"
#include "model/DetectVehicleResult.h"
#include "model/DetectWhiteBaseImageRequest.h"
#include "model/DetectWhiteBaseImageResult.h"
#include "model/GenerateVehicleRepairPlanRequest.h"
#include "model/GenerateVehicleRepairPlanResult.h"
#include "model/GetVehicleRepairPlanRequest.h"
#include "model/GetVehicleRepairPlanResult.h"
#include "model/RecognizeVehicleDamageRequest.h"
#include "model/RecognizeVehicleDamageResult.h"
#include "model/RecognizeVehicleDashboardRequest.h"
#include "model/RecognizeVehicleDashboardResult.h"
#include "model/RecognizeVehiclePartsRequest.h"
#include "model/RecognizeVehiclePartsResult.h"
namespace AlibabaCloud
{
namespace Objectdet
{
class ALIBABACLOUD_OBJECTDET_EXPORT ObjectdetClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ClassifyVehicleInsuranceResult> ClassifyVehicleInsuranceOutcome;
typedef std::future<ClassifyVehicleInsuranceOutcome> ClassifyVehicleInsuranceOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::ClassifyVehicleInsuranceRequest&, const ClassifyVehicleInsuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClassifyVehicleInsuranceAsyncHandler;
typedef Outcome<Error, Model::DetectMainBodyResult> DetectMainBodyOutcome;
typedef std::future<DetectMainBodyOutcome> DetectMainBodyOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::DetectMainBodyRequest&, const DetectMainBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectMainBodyAsyncHandler;
typedef Outcome<Error, Model::DetectObjectResult> DetectObjectOutcome;
typedef std::future<DetectObjectOutcome> DetectObjectOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::DetectObjectRequest&, const DetectObjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectObjectAsyncHandler;
typedef Outcome<Error, Model::DetectTransparentImageResult> DetectTransparentImageOutcome;
typedef std::future<DetectTransparentImageOutcome> DetectTransparentImageOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::DetectTransparentImageRequest&, const DetectTransparentImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectTransparentImageAsyncHandler;
typedef Outcome<Error, Model::DetectVehicleResult> DetectVehicleOutcome;
typedef std::future<DetectVehicleOutcome> DetectVehicleOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::DetectVehicleRequest&, const DetectVehicleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVehicleAsyncHandler;
typedef Outcome<Error, Model::DetectWhiteBaseImageResult> DetectWhiteBaseImageOutcome;
typedef std::future<DetectWhiteBaseImageOutcome> DetectWhiteBaseImageOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::DetectWhiteBaseImageRequest&, const DetectWhiteBaseImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectWhiteBaseImageAsyncHandler;
typedef Outcome<Error, Model::GenerateVehicleRepairPlanResult> GenerateVehicleRepairPlanOutcome;
typedef std::future<GenerateVehicleRepairPlanOutcome> GenerateVehicleRepairPlanOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::GenerateVehicleRepairPlanRequest&, const GenerateVehicleRepairPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateVehicleRepairPlanAsyncHandler;
typedef Outcome<Error, Model::GetVehicleRepairPlanResult> GetVehicleRepairPlanOutcome;
typedef std::future<GetVehicleRepairPlanOutcome> GetVehicleRepairPlanOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::GetVehicleRepairPlanRequest&, const GetVehicleRepairPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVehicleRepairPlanAsyncHandler;
typedef Outcome<Error, Model::RecognizeVehicleDamageResult> RecognizeVehicleDamageOutcome;
typedef std::future<RecognizeVehicleDamageOutcome> RecognizeVehicleDamageOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::RecognizeVehicleDamageRequest&, const RecognizeVehicleDamageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVehicleDamageAsyncHandler;
typedef Outcome<Error, Model::RecognizeVehicleDashboardResult> RecognizeVehicleDashboardOutcome;
typedef std::future<RecognizeVehicleDashboardOutcome> RecognizeVehicleDashboardOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::RecognizeVehicleDashboardRequest&, const RecognizeVehicleDashboardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVehicleDashboardAsyncHandler;
typedef Outcome<Error, Model::RecognizeVehiclePartsResult> RecognizeVehiclePartsOutcome;
typedef std::future<RecognizeVehiclePartsOutcome> RecognizeVehiclePartsOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::RecognizeVehiclePartsRequest&, const RecognizeVehiclePartsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVehiclePartsAsyncHandler;
ObjectdetClient(const Credentials &credentials, const ClientConfiguration &configuration);
ObjectdetClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ObjectdetClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ObjectdetClient();
ClassifyVehicleInsuranceOutcome classifyVehicleInsurance(const Model::ClassifyVehicleInsuranceRequest &request)const;
void classifyVehicleInsuranceAsync(const Model::ClassifyVehicleInsuranceRequest& request, const ClassifyVehicleInsuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ClassifyVehicleInsuranceOutcomeCallable classifyVehicleInsuranceCallable(const Model::ClassifyVehicleInsuranceRequest& request) const;
DetectMainBodyOutcome detectMainBody(const Model::DetectMainBodyRequest &request)const;
void detectMainBodyAsync(const Model::DetectMainBodyRequest& request, const DetectMainBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectMainBodyOutcomeCallable detectMainBodyCallable(const Model::DetectMainBodyRequest& request) const;
DetectObjectOutcome detectObject(const Model::DetectObjectRequest &request)const;
void detectObjectAsync(const Model::DetectObjectRequest& request, const DetectObjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectObjectOutcomeCallable detectObjectCallable(const Model::DetectObjectRequest& request) const;
DetectTransparentImageOutcome detectTransparentImage(const Model::DetectTransparentImageRequest &request)const;
void detectTransparentImageAsync(const Model::DetectTransparentImageRequest& request, const DetectTransparentImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectTransparentImageOutcomeCallable detectTransparentImageCallable(const Model::DetectTransparentImageRequest& request) const;
DetectVehicleOutcome detectVehicle(const Model::DetectVehicleRequest &request)const;
void detectVehicleAsync(const Model::DetectVehicleRequest& request, const DetectVehicleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectVehicleOutcomeCallable detectVehicleCallable(const Model::DetectVehicleRequest& request) const;
DetectWhiteBaseImageOutcome detectWhiteBaseImage(const Model::DetectWhiteBaseImageRequest &request)const;
void detectWhiteBaseImageAsync(const Model::DetectWhiteBaseImageRequest& request, const DetectWhiteBaseImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetectWhiteBaseImageOutcomeCallable detectWhiteBaseImageCallable(const Model::DetectWhiteBaseImageRequest& request) const;
GenerateVehicleRepairPlanOutcome generateVehicleRepairPlan(const Model::GenerateVehicleRepairPlanRequest &request)const;
void generateVehicleRepairPlanAsync(const Model::GenerateVehicleRepairPlanRequest& request, const GenerateVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateVehicleRepairPlanOutcomeCallable generateVehicleRepairPlanCallable(const Model::GenerateVehicleRepairPlanRequest& request) const;
GetVehicleRepairPlanOutcome getVehicleRepairPlan(const Model::GetVehicleRepairPlanRequest &request)const;
void getVehicleRepairPlanAsync(const Model::GetVehicleRepairPlanRequest& request, const GetVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVehicleRepairPlanOutcomeCallable getVehicleRepairPlanCallable(const Model::GetVehicleRepairPlanRequest& request) const;
RecognizeVehicleDamageOutcome recognizeVehicleDamage(const Model::RecognizeVehicleDamageRequest &request)const;
void recognizeVehicleDamageAsync(const Model::RecognizeVehicleDamageRequest& request, const RecognizeVehicleDamageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVehicleDamageOutcomeCallable recognizeVehicleDamageCallable(const Model::RecognizeVehicleDamageRequest& request) const;
RecognizeVehicleDashboardOutcome recognizeVehicleDashboard(const Model::RecognizeVehicleDashboardRequest &request)const;
void recognizeVehicleDashboardAsync(const Model::RecognizeVehicleDashboardRequest& request, const RecognizeVehicleDashboardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVehicleDashboardOutcomeCallable recognizeVehicleDashboardCallable(const Model::RecognizeVehicleDashboardRequest& request) const;
RecognizeVehiclePartsOutcome recognizeVehicleParts(const Model::RecognizeVehiclePartsRequest &request)const;
void recognizeVehiclePartsAsync(const Model::RecognizeVehiclePartsRequest& request, const RecognizeVehiclePartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVehiclePartsOutcomeCallable recognizeVehiclePartsCallable(const Model::RecognizeVehiclePartsRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_OBJECTDET_OBJECTDETCLIENT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/ObjectdetClient.h
|
C++
|
apache-2.0
| 11,857
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_OBJECTDETEXPORT_H_
#define ALIBABACLOUD_OBJECTDET_OBJECTDETEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_OBJECTDET_LIBRARY)
# define ALIBABACLOUD_OBJECTDET_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_OBJECTDET_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_OBJECTDET_EXPORT
#endif
#endif // !ALIBABACLOUD_OBJECTDET_OBJECTDETEXPORT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/ObjectdetExport.h
|
C
|
apache-2.0
| 1,096
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT ClassifyVehicleInsuranceRequest : public RpcServiceRequest
{
public:
ClassifyVehicleInsuranceRequest();
~ClassifyVehicleInsuranceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h
|
C++
|
apache-2.0
| 1,406
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCERESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT ClassifyVehicleInsuranceResult : public ServiceResult
{
public:
struct Data
{
struct Label
{
float score;
std::string name;
};
std::vector<Label> labels;
float threshold;
};
ClassifyVehicleInsuranceResult();
explicit ClassifyVehicleInsuranceResult(const std::string &payload);
~ClassifyVehicleInsuranceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCERESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceResult.h
|
C++
|
apache-2.0
| 1,616
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectMainBodyRequest : public RpcServiceRequest
{
public:
DetectMainBodyRequest();
~DetectMainBodyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectMainBodyRequest.h
|
C++
|
apache-2.0
| 1,346
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_MODEL_DETECTMAINBODYRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectMainBodyResult : public ServiceResult
{
public:
struct Data
{
struct Location
{
int x;
int y;
int height;
int width;
};
Location location;
};
DetectMainBodyResult();
explicit DetectMainBodyResult(const std::string &payload);
~DetectMainBodyResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYRESULT_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectMainBodyResult.h
|
C++
|
apache-2.0
| 1,537
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectObjectRequest : public RpcServiceRequest
{
public:
DetectObjectRequest();
~DetectObjectRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
|
YifuLiu/AliOS-Things
|
components/ucloud_ai/src/model/aliyun-openapi/objectdet/include/alibabacloud/objectdet/model/DetectObjectRequest.h
|
C++
|
apache-2.0
| 1,334
|