Release EstimateMonocularVideoDepth.

VERSION

@@ -1 +1 @@
-1.36.1266
+1.36.1267

threedvision/CMakeLists.txt

@@ -0,0 +1,106 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(threedvision_public_header 
+	include/alibabacloud/threedvision/ThreedvisionClient.h
+	include/alibabacloud/threedvision/ThreedvisionExport.h )
+
+set(threedvision_public_header_model 
+	include/alibabacloud/threedvision/model/EstimateMonocularImageDepthRequest.h
+	include/alibabacloud/threedvision/model/EstimateMonocularImageDepthResult.h
+	include/alibabacloud/threedvision/model/EstimateMonocularVideoDepthRequest.h
+	include/alibabacloud/threedvision/model/EstimateMonocularVideoDepthResult.h
+	include/alibabacloud/threedvision/model/EstimateStereoImageDepthRequest.h
+	include/alibabacloud/threedvision/model/EstimateStereoImageDepthResult.h
+	include/alibabacloud/threedvision/model/GetAsyncJobResultRequest.h
+	include/alibabacloud/threedvision/model/GetAsyncJobResultResult.h
+	include/alibabacloud/threedvision/model/ReconstructBodyBySingleImageRequest.h
+	include/alibabacloud/threedvision/model/ReconstructBodyBySingleImageResult.h
+	include/alibabacloud/threedvision/model/ReconstructThreeDMultiViewRequest.h
+	include/alibabacloud/threedvision/model/ReconstructThreeDMultiViewResult.h )
+
+set(threedvision_src 
+	src/ThreedvisionClient.cc
+	src/model/EstimateMonocularImageDepthRequest.cc
+	src/model/EstimateMonocularImageDepthResult.cc
+	src/model/EstimateMonocularVideoDepthRequest.cc
+	src/model/EstimateMonocularVideoDepthResult.cc
+	src/model/EstimateStereoImageDepthRequest.cc
+	src/model/EstimateStereoImageDepthResult.cc
+	src/model/GetAsyncJobResultRequest.cc
+	src/model/GetAsyncJobResultResult.cc
+	src/model/ReconstructBodyBySingleImageRequest.cc
+	src/model/ReconstructBodyBySingleImageResult.cc
+	src/model/ReconstructThreeDMultiViewRequest.cc
+	src/model/ReconstructThreeDMultiViewResult.cc )
+
+add_library(threedvision ${LIB_TYPE}
+	${threedvision_public_header}
+	${threedvision_public_header_model}
+	${threedvision_src})
+
+set_target_properties(threedvision
+	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}threedvision
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(threedvision
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_THREEDVISION_LIBRARY)
+endif()
+
+target_include_directories(threedvision
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(threedvision
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(threedvision
+		jsoncpp)
+	target_include_directories(threedvision
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(threedvision
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(threedvision
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(threedvision
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(threedvision
+		jsoncpp)
+endif()
+
+install(FILES ${threedvision_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/threedvision)
+install(FILES ${threedvision_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/threedvision/model)
+install(TARGETS threedvision
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

threedvision/include/alibabacloud/threedvision/ThreedvisionClient.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_THREEDVISION_THREEDVISIONCLIENT_H_
+#define ALIBABACLOUD_THREEDVISION_THREEDVISIONCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ThreedvisionExport.h"
+#include "model/EstimateMonocularImageDepthRequest.h"
+#include "model/EstimateMonocularImageDepthResult.h"
+#include "model/EstimateMonocularVideoDepthRequest.h"
+#include "model/EstimateMonocularVideoDepthResult.h"
+#include "model/EstimateStereoImageDepthRequest.h"
+#include "model/EstimateStereoImageDepthResult.h"
+#include "model/GetAsyncJobResultRequest.h"
+#include "model/GetAsyncJobResultResult.h"
+#include "model/ReconstructBodyBySingleImageRequest.h"
+#include "model/ReconstructBodyBySingleImageResult.h"
+#include "model/ReconstructThreeDMultiViewRequest.h"
+#include "model/ReconstructThreeDMultiViewResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Threedvision
+	{
+		class ALIBABACLOUD_THREEDVISION_EXPORT ThreedvisionClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::EstimateMonocularImageDepthResult> EstimateMonocularImageDepthOutcome;
+			typedef std::future<EstimateMonocularImageDepthOutcome> EstimateMonocularImageDepthOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::EstimateMonocularImageDepthRequest&, const EstimateMonocularImageDepthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EstimateMonocularImageDepthAsyncHandler;
+			typedef Outcome<Error, Model::EstimateMonocularVideoDepthResult> EstimateMonocularVideoDepthOutcome;
+			typedef std::future<EstimateMonocularVideoDepthOutcome> EstimateMonocularVideoDepthOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::EstimateMonocularVideoDepthRequest&, const EstimateMonocularVideoDepthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EstimateMonocularVideoDepthAsyncHandler;
+			typedef Outcome<Error, Model::EstimateStereoImageDepthResult> EstimateStereoImageDepthOutcome;
+			typedef std::future<EstimateStereoImageDepthOutcome> EstimateStereoImageDepthOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::EstimateStereoImageDepthRequest&, const EstimateStereoImageDepthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EstimateStereoImageDepthAsyncHandler;
+			typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
+			typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
+			typedef Outcome<Error, Model::ReconstructBodyBySingleImageResult> ReconstructBodyBySingleImageOutcome;
+			typedef std::future<ReconstructBodyBySingleImageOutcome> ReconstructBodyBySingleImageOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::ReconstructBodyBySingleImageRequest&, const ReconstructBodyBySingleImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReconstructBodyBySingleImageAsyncHandler;
+			typedef Outcome<Error, Model::ReconstructThreeDMultiViewResult> ReconstructThreeDMultiViewOutcome;
+			typedef std::future<ReconstructThreeDMultiViewOutcome> ReconstructThreeDMultiViewOutcomeCallable;
+			typedef std::function<void(const ThreedvisionClient*, const Model::ReconstructThreeDMultiViewRequest&, const ReconstructThreeDMultiViewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReconstructThreeDMultiViewAsyncHandler;
+
+			ThreedvisionClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ThreedvisionClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ThreedvisionClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ThreedvisionClient();
+			EstimateMonocularImageDepthOutcome estimateMonocularImageDepth(const Model::EstimateMonocularImageDepthRequest &request)const;
+			void estimateMonocularImageDepthAsync(const Model::EstimateMonocularImageDepthRequest& request, const EstimateMonocularImageDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EstimateMonocularImageDepthOutcomeCallable estimateMonocularImageDepthCallable(const Model::EstimateMonocularImageDepthRequest& request) const;
+			EstimateMonocularVideoDepthOutcome estimateMonocularVideoDepth(const Model::EstimateMonocularVideoDepthRequest &request)const;
+			void estimateMonocularVideoDepthAsync(const Model::EstimateMonocularVideoDepthRequest& request, const EstimateMonocularVideoDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EstimateMonocularVideoDepthOutcomeCallable estimateMonocularVideoDepthCallable(const Model::EstimateMonocularVideoDepthRequest& request) const;
+			EstimateStereoImageDepthOutcome estimateStereoImageDepth(const Model::EstimateStereoImageDepthRequest &request)const;
+			void estimateStereoImageDepthAsync(const Model::EstimateStereoImageDepthRequest& request, const EstimateStereoImageDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EstimateStereoImageDepthOutcomeCallable estimateStereoImageDepthCallable(const Model::EstimateStereoImageDepthRequest& 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;
+			ReconstructBodyBySingleImageOutcome reconstructBodyBySingleImage(const Model::ReconstructBodyBySingleImageRequest &request)const;
+			void reconstructBodyBySingleImageAsync(const Model::ReconstructBodyBySingleImageRequest& request, const ReconstructBodyBySingleImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReconstructBodyBySingleImageOutcomeCallable reconstructBodyBySingleImageCallable(const Model::ReconstructBodyBySingleImageRequest& request) const;
+			ReconstructThreeDMultiViewOutcome reconstructThreeDMultiView(const Model::ReconstructThreeDMultiViewRequest &request)const;
+			void reconstructThreeDMultiViewAsync(const Model::ReconstructThreeDMultiViewRequest& request, const ReconstructThreeDMultiViewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReconstructThreeDMultiViewOutcomeCallable reconstructThreeDMultiViewCallable(const Model::ReconstructThreeDMultiViewRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_THREEDVISION_THREEDVISIONCLIENT_H_

threedvision/include/alibabacloud/threedvision/ThreedvisionExport.h

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

threedvision/include/alibabacloud/threedvision/model/EstimateMonocularImageDepthRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_THREEDVISION_MODEL_ESTIMATEMONOCULARIMAGEDEPTHREQUEST_H_
+#define ALIBABACLOUD_THREEDVISION_MODEL_ESTIMATEMONOCULARIMAGEDEPTHREQUEST_H_
+
+#include <alibabacloud/threedvision/ThreedvisionExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Threedvision {
+namespace Model {
+class ALIBABACLOUD_THREEDVISION_EXPORT EstimateMonocularImageDepthRequest : public RpcServiceRequest {
+public:
+	EstimateMonocularImageDepthRequest();
+	~EstimateMonocularImageDepthRequest();
+	std::string getImageURL() const;
+	void setImageURL(const std::string &imageURL);
+
+private:
+	std::string imageURL_;
+};
+} // namespace Model
+} // namespace Threedvision
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_THREEDVISION_MODEL_ESTIMATEMONOCULARIMAGEDEPTHREQUEST_H_

threedvision/include/alibabacloud/threedvision/model/EstimateMonocularImageDepthResult.h

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

threedvision/include/alibabacloud/threedvision/model/EstimateMonocularVideoDepthRequest.h

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

threedvision/include/alibabacloud/threedvision/model/EstimateMonocularVideoDepthResult.h

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

threedvision/include/alibabacloud/threedvision/model/EstimateStereoImageDepthRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_THREEDVISION_MODEL_ESTIMATESTEREOIMAGEDEPTHREQUEST_H_
+#define ALIBABACLOUD_THREEDVISION_MODEL_ESTIMATESTEREOIMAGEDEPTHREQUEST_H_
+
+#include <alibabacloud/threedvision/ThreedvisionExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Threedvision {
+namespace Model {
+class ALIBABACLOUD_THREEDVISION_EXPORT EstimateStereoImageDepthRequest : public RpcServiceRequest {
+public:
+	EstimateStereoImageDepthRequest();
+	~EstimateStereoImageDepthRequest();
+	std::string getRightImageURL() const;
+	void setRightImageURL(const std::string &rightImageURL);
+	std::string getLeftImageURL() const;
+	void setLeftImageURL(const std::string &leftImageURL);
+
+private:
+	std::string rightImageURL_;
+	std::string leftImageURL_;
+};
+} // namespace Model
+} // namespace Threedvision
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_THREEDVISION_MODEL_ESTIMATESTEREOIMAGEDEPTHREQUEST_H_

threedvision/include/alibabacloud/threedvision/model/EstimateStereoImageDepthResult.h

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

threedvision/include/alibabacloud/threedvision/model/GetAsyncJobResultRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_THREEDVISION_MODEL_GETASYNCJOBRESULTREQUEST_H_
+#define ALIBABACLOUD_THREEDVISION_MODEL_GETASYNCJOBRESULTREQUEST_H_
+
+#include <alibabacloud/threedvision/ThreedvisionExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Threedvision {
+namespace Model {
+class ALIBABACLOUD_THREEDVISION_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
+public:
+	GetAsyncJobResultRequest();
+	~GetAsyncJobResultRequest();
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+	bool getAsync() const;
+	void setAsync(bool async);
+
+private:
+	std::string jobId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Threedvision
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_THREEDVISION_MODEL_GETASYNCJOBRESULTREQUEST_H_

threedvision/include/alibabacloud/threedvision/model/GetAsyncJobResultResult.h

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

threedvision/include/alibabacloud/threedvision/model/ReconstructBodyBySingleImageRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_THREEDVISION_MODEL_RECONSTRUCTBODYBYSINGLEIMAGEREQUEST_H_
+#define ALIBABACLOUD_THREEDVISION_MODEL_RECONSTRUCTBODYBYSINGLEIMAGEREQUEST_H_
+
+#include <alibabacloud/threedvision/ThreedvisionExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Threedvision {
+namespace Model {
+class ALIBABACLOUD_THREEDVISION_EXPORT ReconstructBodyBySingleImageRequest : public RpcServiceRequest {
+public:
+	ReconstructBodyBySingleImageRequest();
+	~ReconstructBodyBySingleImageRequest();
+	std::string getImageURL() const;
+	void setImageURL(const std::string &imageURL);
+
+private:
+	std::string imageURL_;
+};
+} // namespace Model
+} // namespace Threedvision
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_THREEDVISION_MODEL_RECONSTRUCTBODYBYSINGLEIMAGEREQUEST_H_

threedvision/include/alibabacloud/threedvision/model/ReconstructBodyBySingleImageResult.h

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

threedvision/include/alibabacloud/threedvision/model/ReconstructThreeDMultiViewRequest.h

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

threedvision/include/alibabacloud/threedvision/model/ReconstructThreeDMultiViewResult.h

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

threedvision/src/ThreedvisionClient.cc

@@ -0,0 +1,269 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/ThreedvisionClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Threedvision;
+using namespace AlibabaCloud::Threedvision::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "threedvision";
+}
+
+ThreedvisionClient::ThreedvisionClient(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, "threedvision");
+}
+
+ThreedvisionClient::ThreedvisionClient(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, "threedvision");
+}
+
+ThreedvisionClient::ThreedvisionClient(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, "threedvision");
+}
+
+ThreedvisionClient::~ThreedvisionClient()
+{}
+
+ThreedvisionClient::EstimateMonocularImageDepthOutcome ThreedvisionClient::estimateMonocularImageDepth(const EstimateMonocularImageDepthRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EstimateMonocularImageDepthOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EstimateMonocularImageDepthOutcome(EstimateMonocularImageDepthResult(outcome.result()));
+	else
+		return EstimateMonocularImageDepthOutcome(outcome.error());
+}
+
+void ThreedvisionClient::estimateMonocularImageDepthAsync(const EstimateMonocularImageDepthRequest& request, const EstimateMonocularImageDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, estimateMonocularImageDepth(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ThreedvisionClient::EstimateMonocularImageDepthOutcomeCallable ThreedvisionClient::estimateMonocularImageDepthCallable(const EstimateMonocularImageDepthRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EstimateMonocularImageDepthOutcome()>>(
+			[this, request]()
+			{
+			return this->estimateMonocularImageDepth(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ThreedvisionClient::EstimateMonocularVideoDepthOutcome ThreedvisionClient::estimateMonocularVideoDepth(const EstimateMonocularVideoDepthRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EstimateMonocularVideoDepthOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EstimateMonocularVideoDepthOutcome(EstimateMonocularVideoDepthResult(outcome.result()));
+	else
+		return EstimateMonocularVideoDepthOutcome(outcome.error());
+}
+
+void ThreedvisionClient::estimateMonocularVideoDepthAsync(const EstimateMonocularVideoDepthRequest& request, const EstimateMonocularVideoDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, estimateMonocularVideoDepth(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ThreedvisionClient::EstimateMonocularVideoDepthOutcomeCallable ThreedvisionClient::estimateMonocularVideoDepthCallable(const EstimateMonocularVideoDepthRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EstimateMonocularVideoDepthOutcome()>>(
+			[this, request]()
+			{
+			return this->estimateMonocularVideoDepth(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ThreedvisionClient::EstimateStereoImageDepthOutcome ThreedvisionClient::estimateStereoImageDepth(const EstimateStereoImageDepthRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EstimateStereoImageDepthOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EstimateStereoImageDepthOutcome(EstimateStereoImageDepthResult(outcome.result()));
+	else
+		return EstimateStereoImageDepthOutcome(outcome.error());
+}
+
+void ThreedvisionClient::estimateStereoImageDepthAsync(const EstimateStereoImageDepthRequest& request, const EstimateStereoImageDepthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, estimateStereoImageDepth(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ThreedvisionClient::EstimateStereoImageDepthOutcomeCallable ThreedvisionClient::estimateStereoImageDepthCallable(const EstimateStereoImageDepthRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EstimateStereoImageDepthOutcome()>>(
+			[this, request]()
+			{
+			return this->estimateStereoImageDepth(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ThreedvisionClient::GetAsyncJobResultOutcome ThreedvisionClient::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 ThreedvisionClient::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));
+}
+
+ThreedvisionClient::GetAsyncJobResultOutcomeCallable ThreedvisionClient::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();
+}
+
+ThreedvisionClient::ReconstructBodyBySingleImageOutcome ThreedvisionClient::reconstructBodyBySingleImage(const ReconstructBodyBySingleImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReconstructBodyBySingleImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReconstructBodyBySingleImageOutcome(ReconstructBodyBySingleImageResult(outcome.result()));
+	else
+		return ReconstructBodyBySingleImageOutcome(outcome.error());
+}
+
+void ThreedvisionClient::reconstructBodyBySingleImageAsync(const ReconstructBodyBySingleImageRequest& request, const ReconstructBodyBySingleImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, reconstructBodyBySingleImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ThreedvisionClient::ReconstructBodyBySingleImageOutcomeCallable ThreedvisionClient::reconstructBodyBySingleImageCallable(const ReconstructBodyBySingleImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReconstructBodyBySingleImageOutcome()>>(
+			[this, request]()
+			{
+			return this->reconstructBodyBySingleImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ThreedvisionClient::ReconstructThreeDMultiViewOutcome ThreedvisionClient::reconstructThreeDMultiView(const ReconstructThreeDMultiViewRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReconstructThreeDMultiViewOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReconstructThreeDMultiViewOutcome(ReconstructThreeDMultiViewResult(outcome.result()));
+	else
+		return ReconstructThreeDMultiViewOutcome(outcome.error());
+}
+
+void ThreedvisionClient::reconstructThreeDMultiViewAsync(const ReconstructThreeDMultiViewRequest& request, const ReconstructThreeDMultiViewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, reconstructThreeDMultiView(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ThreedvisionClient::ReconstructThreeDMultiViewOutcomeCallable ThreedvisionClient::reconstructThreeDMultiViewCallable(const ReconstructThreeDMultiViewRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReconstructThreeDMultiViewOutcome()>>(
+			[this, request]()
+			{
+			return this->reconstructThreeDMultiView(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

threedvision/src/model/EstimateMonocularImageDepthRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/EstimateMonocularImageDepthRequest.h>
+
+using AlibabaCloud::Threedvision::Model::EstimateMonocularImageDepthRequest;
+
+EstimateMonocularImageDepthRequest::EstimateMonocularImageDepthRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "EstimateMonocularImageDepth") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EstimateMonocularImageDepthRequest::~EstimateMonocularImageDepthRequest() {}
+
+std::string EstimateMonocularImageDepthRequest::getImageURL() const {
+  return imageURL_;
+}
+
+void EstimateMonocularImageDepthRequest::setImageURL(const std::string &imageURL) {
+  imageURL_ = imageURL;
+  setBodyParameter(std::string("ImageURL"), imageURL);
+}
+

threedvision/src/model/EstimateMonocularImageDepthResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/EstimateMonocularImageDepthResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Threedvision;
+using namespace AlibabaCloud::Threedvision::Model;
+
+EstimateMonocularImageDepthResult::EstimateMonocularImageDepthResult() :
+	ServiceResult()
+{}
+
+EstimateMonocularImageDepthResult::EstimateMonocularImageDepthResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EstimateMonocularImageDepthResult::~EstimateMonocularImageDepthResult()
+{}
+
+void EstimateMonocularImageDepthResult::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["DepthMapUrl"].isNull())
+		data_.depthMapUrl = dataNode["DepthMapUrl"].asString();
+	if(!dataNode["DepthToColorUrl"].isNull())
+		data_.depthToColorUrl = dataNode["DepthToColorUrl"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string EstimateMonocularImageDepthResult::getMessage()const
+{
+	return message_;
+}
+
+EstimateMonocularImageDepthResult::Data EstimateMonocularImageDepthResult::getData()const
+{
+	return data_;
+}
+
+std::string EstimateMonocularImageDepthResult::getCode()const
+{
+	return code_;
+}
+

threedvision/src/model/EstimateMonocularVideoDepthRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/threedvision/model/EstimateMonocularVideoDepthRequest.h>
+
+using AlibabaCloud::Threedvision::Model::EstimateMonocularVideoDepthRequest;
+
+EstimateMonocularVideoDepthRequest::EstimateMonocularVideoDepthRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "EstimateMonocularVideoDepth") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EstimateMonocularVideoDepthRequest::~EstimateMonocularVideoDepthRequest() {}
+
+std::string EstimateMonocularVideoDepthRequest::getSampleRate() const {
+  return sampleRate_;
+}
+
+void EstimateMonocularVideoDepthRequest::setSampleRate(const std::string &sampleRate) {
+  sampleRate_ = sampleRate;
+  setBodyParameter(std::string("SampleRate"), sampleRate);
+}
+
+bool EstimateMonocularVideoDepthRequest::getAsync() const {
+  return async_;
+}
+
+void EstimateMonocularVideoDepthRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
+}
+
+std::string EstimateMonocularVideoDepthRequest::getVideoURL() const {
+  return videoURL_;
+}
+
+void EstimateMonocularVideoDepthRequest::setVideoURL(const std::string &videoURL) {
+  videoURL_ = videoURL;
+  setBodyParameter(std::string("VideoURL"), videoURL);
+}
+

threedvision/src/model/EstimateMonocularVideoDepthResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/EstimateMonocularVideoDepthResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Threedvision;
+using namespace AlibabaCloud::Threedvision::Model;
+
+EstimateMonocularVideoDepthResult::EstimateMonocularVideoDepthResult() :
+	ServiceResult()
+{}
+
+EstimateMonocularVideoDepthResult::EstimateMonocularVideoDepthResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EstimateMonocularVideoDepthResult::~EstimateMonocularVideoDepthResult()
+{}
+
+void EstimateMonocularVideoDepthResult::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["DepthUrl"].isNull())
+		data_.depthUrl = dataNode["DepthUrl"].asString();
+	if(!dataNode["DepthVisUrl"].isNull())
+		data_.depthVisUrl = dataNode["DepthVisUrl"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string EstimateMonocularVideoDepthResult::getMessage()const
+{
+	return message_;
+}
+
+EstimateMonocularVideoDepthResult::Data EstimateMonocularVideoDepthResult::getData()const
+{
+	return data_;
+}
+
+std::string EstimateMonocularVideoDepthResult::getCode()const
+{
+	return code_;
+}
+

threedvision/src/model/EstimateStereoImageDepthRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/EstimateStereoImageDepthRequest.h>
+
+using AlibabaCloud::Threedvision::Model::EstimateStereoImageDepthRequest;
+
+EstimateStereoImageDepthRequest::EstimateStereoImageDepthRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "EstimateStereoImageDepth") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EstimateStereoImageDepthRequest::~EstimateStereoImageDepthRequest() {}
+
+std::string EstimateStereoImageDepthRequest::getRightImageURL() const {
+  return rightImageURL_;
+}
+
+void EstimateStereoImageDepthRequest::setRightImageURL(const std::string &rightImageURL) {
+  rightImageURL_ = rightImageURL;
+  setBodyParameter(std::string("RightImageURL"), rightImageURL);
+}
+
+std::string EstimateStereoImageDepthRequest::getLeftImageURL() const {
+  return leftImageURL_;
+}
+
+void EstimateStereoImageDepthRequest::setLeftImageURL(const std::string &leftImageURL) {
+  leftImageURL_ = leftImageURL;
+  setBodyParameter(std::string("LeftImageURL"), leftImageURL);
+}
+

threedvision/src/model/EstimateStereoImageDepthResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/EstimateStereoImageDepthResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Threedvision;
+using namespace AlibabaCloud::Threedvision::Model;
+
+EstimateStereoImageDepthResult::EstimateStereoImageDepthResult() :
+	ServiceResult()
+{}
+
+EstimateStereoImageDepthResult::EstimateStereoImageDepthResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EstimateStereoImageDepthResult::~EstimateStereoImageDepthResult()
+{}
+
+void EstimateStereoImageDepthResult::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["DisparityMapURL"].isNull())
+		data_.disparityMapURL = dataNode["DisparityMapURL"].asString();
+	if(!dataNode["DisparityVisURL"].isNull())
+		data_.disparityVisURL = dataNode["DisparityVisURL"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string EstimateStereoImageDepthResult::getMessage()const
+{
+	return message_;
+}
+
+EstimateStereoImageDepthResult::Data EstimateStereoImageDepthResult::getData()const
+{
+	return data_;
+}
+
+std::string EstimateStereoImageDepthResult::getCode()const
+{
+	return code_;
+}
+

threedvision/src/model/GetAsyncJobResultRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/GetAsyncJobResultRequest.h>
+
+using AlibabaCloud::Threedvision::Model::GetAsyncJobResultRequest;
+
+GetAsyncJobResultRequest::GetAsyncJobResultRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "GetAsyncJobResult") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
+
+std::string GetAsyncJobResultRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setBodyParameter(std::string("JobId"), jobId);
+}
+
+bool GetAsyncJobResultRequest::getAsync() const {
+  return async_;
+}
+
+void GetAsyncJobResultRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
+}
+

threedvision/src/model/GetAsyncJobResultResult.cc

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

threedvision/src/model/ReconstructBodyBySingleImageRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/ReconstructBodyBySingleImageRequest.h>
+
+using AlibabaCloud::Threedvision::Model::ReconstructBodyBySingleImageRequest;
+
+ReconstructBodyBySingleImageRequest::ReconstructBodyBySingleImageRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "ReconstructBodyBySingleImage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ReconstructBodyBySingleImageRequest::~ReconstructBodyBySingleImageRequest() {}
+
+std::string ReconstructBodyBySingleImageRequest::getImageURL() const {
+  return imageURL_;
+}
+
+void ReconstructBodyBySingleImageRequest::setImageURL(const std::string &imageURL) {
+  imageURL_ = imageURL;
+  setBodyParameter(std::string("ImageURL"), imageURL);
+}
+

threedvision/src/model/ReconstructBodyBySingleImageResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/threedvision/model/ReconstructBodyBySingleImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Threedvision;
+using namespace AlibabaCloud::Threedvision::Model;
+
+ReconstructBodyBySingleImageResult::ReconstructBodyBySingleImageResult() :
+	ServiceResult()
+{}
+
+ReconstructBodyBySingleImageResult::ReconstructBodyBySingleImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ReconstructBodyBySingleImageResult::~ReconstructBodyBySingleImageResult()
+{}
+
+void ReconstructBodyBySingleImageResult::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["DepthURL"].isNull())
+		data_.depthURL = dataNode["DepthURL"].asString();
+	if(!dataNode["MeshURL"].isNull())
+		data_.meshURL = dataNode["MeshURL"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ReconstructBodyBySingleImageResult::getMessage()const
+{
+	return message_;
+}
+
+ReconstructBodyBySingleImageResult::Data ReconstructBodyBySingleImageResult::getData()const
+{
+	return data_;
+}
+
+std::string ReconstructBodyBySingleImageResult::getCode()const
+{
+	return code_;
+}
+

threedvision/src/model/ReconstructThreeDMultiViewRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/threedvision/model/ReconstructThreeDMultiViewRequest.h>
+
+using AlibabaCloud::Threedvision::Model::ReconstructThreeDMultiViewRequest;
+
+ReconstructThreeDMultiViewRequest::ReconstructThreeDMultiViewRequest()
+    : RpcServiceRequest("threedvision", "2021-01-31", "ReconstructThreeDMultiView") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ReconstructThreeDMultiViewRequest::~ReconstructThreeDMultiViewRequest() {}
+
+std::string ReconstructThreeDMultiViewRequest::getMode() const {
+  return mode_;
+}
+
+void ReconstructThreeDMultiViewRequest::setMode(const std::string &mode) {
+  mode_ = mode;
+  setBodyParameter(std::string("Mode"), mode);
+}
+
+std::string ReconstructThreeDMultiViewRequest::getZipFileUrl() const {
+  return zipFileUrl_;
+}
+
+void ReconstructThreeDMultiViewRequest::setZipFileUrl(const std::string &zipFileUrl) {
+  zipFileUrl_ = zipFileUrl;
+  setBodyParameter(std::string("ZipFileUrl"), zipFileUrl);
+}
+
+bool ReconstructThreeDMultiViewRequest::getAsync() const {
+  return async_;
+}
+
+void ReconstructThreeDMultiViewRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
+}
+

threedvision/src/model/ReconstructThreeDMultiViewResult.cc

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