Release DetectVehicleIllegalParking DetectVehicleICongestion.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-02-01 Version: patch
+- Release DetectVehicleIllegalParking DetectVehicleICongestion.
+
 2021-01-31 Version: patch
 - ConvertInstance.
 

objectdet/CMakeLists.txt

@@ -23,6 +23,8 @@ set(objectdet_public_header
 set(objectdet_public_header_model 
 	include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h
 	include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceResult.h
+	include/alibabacloud/objectdet/model/DetectIPCObjectRequest.h
+	include/alibabacloud/objectdet/model/DetectIPCObjectResult.h
 	include/alibabacloud/objectdet/model/DetectMainBodyRequest.h
 	include/alibabacloud/objectdet/model/DetectMainBodyResult.h
 	include/alibabacloud/objectdet/model/DetectObjectRequest.h
@@ -31,6 +33,10 @@ set(objectdet_public_header_model
 	include/alibabacloud/objectdet/model/DetectTransparentImageResult.h
 	include/alibabacloud/objectdet/model/DetectVehicleRequest.h
 	include/alibabacloud/objectdet/model/DetectVehicleResult.h
+	include/alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h
+	include/alibabacloud/objectdet/model/DetectVehicleICongestionResult.h
+	include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h
+	include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingResult.h
 	include/alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h
 	include/alibabacloud/objectdet/model/DetectWhiteBaseImageResult.h
 	include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h
@@ -48,6 +54,8 @@ set(objectdet_src
 	src/ObjectdetClient.cc
 	src/model/ClassifyVehicleInsuranceRequest.cc
 	src/model/ClassifyVehicleInsuranceResult.cc
+	src/model/DetectIPCObjectRequest.cc
+	src/model/DetectIPCObjectResult.cc
 	src/model/DetectMainBodyRequest.cc
 	src/model/DetectMainBodyResult.cc
 	src/model/DetectObjectRequest.cc
@@ -56,6 +64,10 @@ set(objectdet_src
 	src/model/DetectTransparentImageResult.cc
 	src/model/DetectVehicleRequest.cc
 	src/model/DetectVehicleResult.cc
+	src/model/DetectVehicleICongestionRequest.cc
+	src/model/DetectVehicleICongestionResult.cc
+	src/model/DetectVehicleIllegalParkingRequest.cc
+	src/model/DetectVehicleIllegalParkingResult.cc
 	src/model/DetectWhiteBaseImageRequest.cc
 	src/model/DetectWhiteBaseImageResult.cc
 	src/model/GenerateVehicleRepairPlanRequest.cc

objectdet/include/alibabacloud/objectdet/ObjectdetClient.h

@@ -24,6 +24,8 @@
 #include "ObjectdetExport.h"
 #include "model/ClassifyVehicleInsuranceRequest.h"
 #include "model/ClassifyVehicleInsuranceResult.h"
+#include "model/DetectIPCObjectRequest.h"
+#include "model/DetectIPCObjectResult.h"
 #include "model/DetectMainBodyRequest.h"
 #include "model/DetectMainBodyResult.h"
 #include "model/DetectObjectRequest.h"
@@ -32,6 +34,10 @@
 #include "model/DetectTransparentImageResult.h"
 #include "model/DetectVehicleRequest.h"
 #include "model/DetectVehicleResult.h"
+#include "model/DetectVehicleICongestionRequest.h"
+#include "model/DetectVehicleICongestionResult.h"
+#include "model/DetectVehicleIllegalParkingRequest.h"
+#include "model/DetectVehicleIllegalParkingResult.h"
 #include "model/DetectWhiteBaseImageRequest.h"
 #include "model/DetectWhiteBaseImageResult.h"
 #include "model/GenerateVehicleRepairPlanRequest.h"
@@ -56,6 +62,9 @@ namespace AlibabaCloud
 			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::DetectIPCObjectResult> DetectIPCObjectOutcome;
+			typedef std::future<DetectIPCObjectOutcome> DetectIPCObjectOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectIPCObjectRequest&, const DetectIPCObjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectIPCObjectAsyncHandler;
 			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;
@@ -68,6 +77,12 @@ namespace AlibabaCloud
 			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::DetectVehicleICongestionResult> DetectVehicleICongestionOutcome;
+			typedef std::future<DetectVehicleICongestionOutcome> DetectVehicleICongestionOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectVehicleICongestionRequest&, const DetectVehicleICongestionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVehicleICongestionAsyncHandler;
+			typedef Outcome<Error, Model::DetectVehicleIllegalParkingResult> DetectVehicleIllegalParkingOutcome;
+			typedef std::future<DetectVehicleIllegalParkingOutcome> DetectVehicleIllegalParkingOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectVehicleIllegalParkingRequest&, const DetectVehicleIllegalParkingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVehicleIllegalParkingAsyncHandler;
 			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;
@@ -94,6 +109,9 @@ namespace AlibabaCloud
 			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;
+			DetectIPCObjectOutcome detectIPCObject(const Model::DetectIPCObjectRequest &request)const;
+			void detectIPCObjectAsync(const Model::DetectIPCObjectRequest& request, const DetectIPCObjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectIPCObjectOutcomeCallable detectIPCObjectCallable(const Model::DetectIPCObjectRequest& 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;
@@ -106,6 +124,12 @@ namespace AlibabaCloud
 			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;
+			DetectVehicleICongestionOutcome detectVehicleICongestion(const Model::DetectVehicleICongestionRequest &request)const;
+			void detectVehicleICongestionAsync(const Model::DetectVehicleICongestionRequest& request, const DetectVehicleICongestionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectVehicleICongestionOutcomeCallable detectVehicleICongestionCallable(const Model::DetectVehicleICongestionRequest& request) const;
+			DetectVehicleIllegalParkingOutcome detectVehicleIllegalParking(const Model::DetectVehicleIllegalParkingRequest &request)const;
+			void detectVehicleIllegalParkingAsync(const Model::DetectVehicleIllegalParkingRequest& request, const DetectVehicleIllegalParkingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectVehicleIllegalParkingOutcomeCallable detectVehicleIllegalParkingCallable(const Model::DetectVehicleIllegalParkingRequest& 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;

objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectRequest.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_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_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 DetectIPCObjectRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectIPCObjectRequest();
+				~DetectIPCObjectRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTRESULT_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTRESULT_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 DetectIPCObjectResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Element
+					{
+						float score;
+						std::string type;
+						std::vector<std::string> box;
+					};
+					std::vector<Element> elements;
+				};
+
+
+				DetectIPCObjectResult();
+				explicit DetectIPCObjectResult(const std::string &payload);
+				~DetectIPCObjectResult();
+				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_OBJECTDET_MODEL_DETECTIPCOBJECTRESULT_H_

objectdet/include/alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_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 DetectVehicleICongestionRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectVehicleICongestionRequest();
+				~DetectVehicleICongestionRequest();
+
+				Array getRoadRegions()const;
+				void setRoadRegions(const Array& roadRegions);
+				Array getPreRegionIntersectFeatures()const;
+				void setPreRegionIntersectFeatures(const Array& preRegionIntersectFeatures);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				Array roadRegions_;
+				Array preRegionIntersectFeatures_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectVehicleICongestionResult.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DETECTVEHICLEICONGESTIONRESULT_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONRESULT_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 DetectVehicleICongestionResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct RegionIntersectFeaturesItem
+					{
+						std::vector<std::string> features;
+					};
+					struct RegionIntersectsItem
+					{
+						std::vector<std::string> ids;
+					};
+					struct RegionIntersectMatchedItem
+					{
+						std::vector<std::string> ids1;
+					};
+					struct Element
+					{
+						struct BoxesItem
+						{
+							long left;
+							long top;
+							long right;
+							long bottom;
+						};
+						std::string typeName;
+						float score;
+						std::vector<Element::BoxesItem> boxes;
+					};
+					std::vector<RegionIntersectFeaturesItem> regionIntersectFeatures;
+					std::vector<RegionIntersectsItem> regionIntersects;
+					std::vector<RegionIntersectMatchedItem> regionIntersectMatched;
+					std::vector<Element> elements;
+				};
+
+
+				DetectVehicleICongestionResult();
+				explicit DetectVehicleICongestionResult(const std::string &payload);
+				~DetectVehicleICongestionResult();
+				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_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONRESULT_H_

objectdet/include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_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 DetectVehicleIllegalParkingRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectVehicleIllegalParkingRequest();
+				~DetectVehicleIllegalParkingRequest();
+
+				Array getRoadRegions()const;
+				void setRoadRegions(const Array& roadRegions);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				Array roadRegions_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DETECTVEHICLEILLEGALPARKINGRESULT_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGRESULT_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 DetectVehicleIllegalParkingResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct RegionIntersect
+					{
+						std::vector<std::string> ids;
+					};
+					struct Element
+					{
+						struct BoxesItem
+						{
+							long left;
+							long top;
+							long right;
+							long bottom;
+						};
+						std::string typeName;
+						float score;
+						std::vector<Element::BoxesItem> boxes;
+					};
+					std::vector<RegionIntersect> regionIntersects;
+					std::vector<Element> elements;
+				};
+
+
+				DetectVehicleIllegalParkingResult();
+				explicit DetectVehicleIllegalParkingResult(const std::string &payload);
+				~DetectVehicleIllegalParkingResult();
+				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_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGRESULT_H_

objectdet/src/ObjectdetClient.cc

@@ -87,6 +87,42 @@ ObjectdetClient::ClassifyVehicleInsuranceOutcomeCallable ObjectdetClient::classi
 	return task->get_future();
 }
 
+ObjectdetClient::DetectIPCObjectOutcome ObjectdetClient::detectIPCObject(const DetectIPCObjectRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectIPCObjectOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectIPCObjectOutcome(DetectIPCObjectResult(outcome.result()));
+	else
+		return DetectIPCObjectOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectIPCObjectAsync(const DetectIPCObjectRequest& request, const DetectIPCObjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectIPCObject(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectIPCObjectOutcomeCallable ObjectdetClient::detectIPCObjectCallable(const DetectIPCObjectRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectIPCObjectOutcome()>>(
+			[this, request]()
+			{
+			return this->detectIPCObject(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ObjectdetClient::DetectMainBodyOutcome ObjectdetClient::detectMainBody(const DetectMainBodyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +267,78 @@ ObjectdetClient::DetectVehicleOutcomeCallable ObjectdetClient::detectVehicleCall
 	return task->get_future();
 }
 
+ObjectdetClient::DetectVehicleICongestionOutcome ObjectdetClient::detectVehicleICongestion(const DetectVehicleICongestionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectVehicleICongestionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectVehicleICongestionOutcome(DetectVehicleICongestionResult(outcome.result()));
+	else
+		return DetectVehicleICongestionOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectVehicleICongestionAsync(const DetectVehicleICongestionRequest& request, const DetectVehicleICongestionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectVehicleICongestion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectVehicleICongestionOutcomeCallable ObjectdetClient::detectVehicleICongestionCallable(const DetectVehicleICongestionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectVehicleICongestionOutcome()>>(
+			[this, request]()
+			{
+			return this->detectVehicleICongestion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ObjectdetClient::DetectVehicleIllegalParkingOutcome ObjectdetClient::detectVehicleIllegalParking(const DetectVehicleIllegalParkingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectVehicleIllegalParkingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectVehicleIllegalParkingOutcome(DetectVehicleIllegalParkingResult(outcome.result()));
+	else
+		return DetectVehicleIllegalParkingOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectVehicleIllegalParkingAsync(const DetectVehicleIllegalParkingRequest& request, const DetectVehicleIllegalParkingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectVehicleIllegalParking(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectVehicleIllegalParkingOutcomeCallable ObjectdetClient::detectVehicleIllegalParkingCallable(const DetectVehicleIllegalParkingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectVehicleIllegalParkingOutcome()>>(
+			[this, request]()
+			{
+			return this->detectVehicleIllegalParking(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ObjectdetClient::DetectWhiteBaseImageOutcome ObjectdetClient::detectWhiteBaseImage(const DetectWhiteBaseImageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

objectdet/src/model/DetectIPCObjectRequest.cc

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

objectdet/src/model/DetectIPCObjectResult.cc

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

objectdet/src/model/DetectVehicleICongestionRequest.cc

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

objectdet/src/model/DetectVehicleICongestionResult.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/objectdet/model/DetectVehicleICongestionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Objectdet;
+using namespace AlibabaCloud::Objectdet::Model;
+
+DetectVehicleICongestionResult::DetectVehicleICongestionResult() :
+	ServiceResult()
+{}
+
+DetectVehicleICongestionResult::DetectVehicleICongestionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectVehicleICongestionResult::~DetectVehicleICongestionResult()
+{}
+
+void DetectVehicleICongestionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allRegionIntersectFeaturesNode = dataNode["RegionIntersectFeatures"]["RegionIntersectFeaturesItem"];
+	for (auto dataNodeRegionIntersectFeaturesRegionIntersectFeaturesItem : allRegionIntersectFeaturesNode)
+	{
+		Data::RegionIntersectFeaturesItem regionIntersectFeaturesItemObject;
+		auto allFeatures = value["Features"]["Features"];
+		for (auto value : allFeatures)
+			regionIntersectFeaturesItemObject.features.push_back(value.asString());
+		data_.regionIntersectFeatures.push_back(regionIntersectFeaturesItemObject);
+	}
+	auto allRegionIntersectsNode = dataNode["RegionIntersects"]["RegionIntersectsItem"];
+	for (auto dataNodeRegionIntersectsRegionIntersectsItem : allRegionIntersectsNode)
+	{
+		Data::RegionIntersectsItem regionIntersectsItemObject;
+		auto allIds = value["Ids"]["Ids"];
+		for (auto value : allIds)
+			regionIntersectsItemObject.ids.push_back(value.asString());
+		data_.regionIntersects.push_back(regionIntersectsItemObject);
+	}
+	auto allRegionIntersectMatchedNode = dataNode["RegionIntersectMatched"]["RegionIntersectMatchedItem"];
+	for (auto dataNodeRegionIntersectMatchedRegionIntersectMatchedItem : allRegionIntersectMatchedNode)
+	{
+		Data::RegionIntersectMatchedItem regionIntersectMatchedItemObject;
+		auto allIds1 = value["Ids"]["Ids"];
+		for (auto value : allIds1)
+			regionIntersectMatchedItemObject.ids1.push_back(value.asString());
+		data_.regionIntersectMatched.push_back(regionIntersectMatchedItemObject);
+	}
+	auto allElementsNode = dataNode["Elements"]["Element"];
+	for (auto dataNodeElementsElement : allElementsNode)
+	{
+		Data::Element elementObject;
+		if(!dataNodeElementsElement["TypeName"].isNull())
+			elementObject.typeName = dataNodeElementsElement["TypeName"].asString();
+		if(!dataNodeElementsElement["Score"].isNull())
+			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
+		auto allBoxesNode = dataNodeElementsElement["Boxes"]["BoxesItem"];
+		for (auto dataNodeElementsElementBoxesBoxesItem : allBoxesNode)
+		{
+			Data::Element::BoxesItem boxesObject;
+			if(!dataNodeElementsElementBoxesBoxesItem["Left"].isNull())
+				boxesObject.left = std::stol(dataNodeElementsElementBoxesBoxesItem["Left"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Top"].isNull())
+				boxesObject.top = std::stol(dataNodeElementsElementBoxesBoxesItem["Top"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Right"].isNull())
+				boxesObject.right = std::stol(dataNodeElementsElementBoxesBoxesItem["Right"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Bottom"].isNull())
+				boxesObject.bottom = std::stol(dataNodeElementsElementBoxesBoxesItem["Bottom"].asString());
+			elementObject.boxes.push_back(boxesObject);
+		}
+		data_.elements.push_back(elementObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+std::string DetectVehicleICongestionResult::getMessage()const
+{
+	return message_;
+}
+
+DetectVehicleICongestionResult::Data DetectVehicleICongestionResult::getData()const
+{
+	return data_;
+}
+
+std::string DetectVehicleICongestionResult::getCode()const
+{
+	return code_;
+}
+

objectdet/src/model/DetectVehicleIllegalParkingRequest.cc

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

objectdet/src/model/DetectVehicleIllegalParkingResult.cc

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/objectdet/model/DetectVehicleIllegalParkingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Objectdet;
+using namespace AlibabaCloud::Objectdet::Model;
+
+DetectVehicleIllegalParkingResult::DetectVehicleIllegalParkingResult() :
+	ServiceResult()
+{}
+
+DetectVehicleIllegalParkingResult::DetectVehicleIllegalParkingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectVehicleIllegalParkingResult::~DetectVehicleIllegalParkingResult()
+{}
+
+void DetectVehicleIllegalParkingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allRegionIntersectsNode = dataNode["RegionIntersects"]["RegionIntersect"];
+	for (auto dataNodeRegionIntersectsRegionIntersect : allRegionIntersectsNode)
+	{
+		Data::RegionIntersect regionIntersectObject;
+		auto allIds = value["Ids"]["Ids"];
+		for (auto value : allIds)
+			regionIntersectObject.ids.push_back(value.asString());
+		data_.regionIntersects.push_back(regionIntersectObject);
+	}
+	auto allElementsNode = dataNode["Elements"]["Element"];
+	for (auto dataNodeElementsElement : allElementsNode)
+	{
+		Data::Element elementObject;
+		if(!dataNodeElementsElement["TypeName"].isNull())
+			elementObject.typeName = dataNodeElementsElement["TypeName"].asString();
+		if(!dataNodeElementsElement["Score"].isNull())
+			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
+		auto allBoxesNode = dataNodeElementsElement["Boxes"]["BoxesItem"];
+		for (auto dataNodeElementsElementBoxesBoxesItem : allBoxesNode)
+		{
+			Data::Element::BoxesItem boxesObject;
+			if(!dataNodeElementsElementBoxesBoxesItem["Left"].isNull())
+				boxesObject.left = std::stol(dataNodeElementsElementBoxesBoxesItem["Left"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Top"].isNull())
+				boxesObject.top = std::stol(dataNodeElementsElementBoxesBoxesItem["Top"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Right"].isNull())
+				boxesObject.right = std::stol(dataNodeElementsElementBoxesBoxesItem["Right"].asString());
+			if(!dataNodeElementsElementBoxesBoxesItem["Bottom"].isNull())
+				boxesObject.bottom = std::stol(dataNodeElementsElementBoxesBoxesItem["Bottom"].asString());
+			elementObject.boxes.push_back(boxesObject);
+		}
+		data_.elements.push_back(elementObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+std::string DetectVehicleIllegalParkingResult::getMessage()const
+{
+	return message_;
+}
+
+DetectVehicleIllegalParkingResult::Data DetectVehicleIllegalParkingResult::getData()const
+{
+	return data_;
+}
+
+std::string DetectVehicleIllegalParkingResult::getCode()const
+{
+	return code_;
+}
+