Release DetectKitchenAnimals DetectWorkwear.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-11-01 Version: 1.36.915
+- Release DetectKitchenAnimals DetectWorkwear.
+
 2021-10-28 Version: 1.36.914
 - Add no data alarm processing.
 

VERSION

@@ -1 +1 @@
-1.36.914
+1.36.915

objectdet/CMakeLists.txt

@@ -25,6 +25,8 @@ set(objectdet_public_header_model
 	include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceResult.h
 	include/alibabacloud/objectdet/model/DetectIPCObjectRequest.h
 	include/alibabacloud/objectdet/model/DetectIPCObjectResult.h
+	include/alibabacloud/objectdet/model/DetectKitchenAnimalsRequest.h
+	include/alibabacloud/objectdet/model/DetectKitchenAnimalsResult.h
 	include/alibabacloud/objectdet/model/DetectMainBodyRequest.h
 	include/alibabacloud/objectdet/model/DetectMainBodyResult.h
 	include/alibabacloud/objectdet/model/DetectObjectRequest.h
@@ -37,10 +39,14 @@ set(objectdet_public_header_model
 	include/alibabacloud/objectdet/model/DetectVehicleICongestionResult.h
 	include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h
 	include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingResult.h
+	include/alibabacloud/objectdet/model/DetectVideoFrameRequest.h
+	include/alibabacloud/objectdet/model/DetectVideoFrameResult.h
 	include/alibabacloud/objectdet/model/DetectVideoIPCObjectRequest.h
 	include/alibabacloud/objectdet/model/DetectVideoIPCObjectResult.h
 	include/alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h
 	include/alibabacloud/objectdet/model/DetectWhiteBaseImageResult.h
+	include/alibabacloud/objectdet/model/DetectWorkwearRequest.h
+	include/alibabacloud/objectdet/model/DetectWorkwearResult.h
 	include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h
 	include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanResult.h
 	include/alibabacloud/objectdet/model/GetAsyncJobResultRequest.h
@@ -60,6 +66,8 @@ set(objectdet_src
 	src/model/ClassifyVehicleInsuranceResult.cc
 	src/model/DetectIPCObjectRequest.cc
 	src/model/DetectIPCObjectResult.cc
+	src/model/DetectKitchenAnimalsRequest.cc
+	src/model/DetectKitchenAnimalsResult.cc
 	src/model/DetectMainBodyRequest.cc
 	src/model/DetectMainBodyResult.cc
 	src/model/DetectObjectRequest.cc
@@ -72,10 +80,14 @@ set(objectdet_src
 	src/model/DetectVehicleICongestionResult.cc
 	src/model/DetectVehicleIllegalParkingRequest.cc
 	src/model/DetectVehicleIllegalParkingResult.cc
+	src/model/DetectVideoFrameRequest.cc
+	src/model/DetectVideoFrameResult.cc
 	src/model/DetectVideoIPCObjectRequest.cc
 	src/model/DetectVideoIPCObjectResult.cc
 	src/model/DetectWhiteBaseImageRequest.cc
 	src/model/DetectWhiteBaseImageResult.cc
+	src/model/DetectWorkwearRequest.cc
+	src/model/DetectWorkwearResult.cc
 	src/model/GenerateVehicleRepairPlanRequest.cc
 	src/model/GenerateVehicleRepairPlanResult.cc
 	src/model/GetAsyncJobResultRequest.cc

objectdet/include/alibabacloud/objectdet/ObjectdetClient.h

@@ -26,6 +26,8 @@
 #include "model/ClassifyVehicleInsuranceResult.h"
 #include "model/DetectIPCObjectRequest.h"
 #include "model/DetectIPCObjectResult.h"
+#include "model/DetectKitchenAnimalsRequest.h"
+#include "model/DetectKitchenAnimalsResult.h"
 #include "model/DetectMainBodyRequest.h"
 #include "model/DetectMainBodyResult.h"
 #include "model/DetectObjectRequest.h"
@@ -38,10 +40,14 @@
 #include "model/DetectVehicleICongestionResult.h"
 #include "model/DetectVehicleIllegalParkingRequest.h"
 #include "model/DetectVehicleIllegalParkingResult.h"
+#include "model/DetectVideoFrameRequest.h"
+#include "model/DetectVideoFrameResult.h"
 #include "model/DetectVideoIPCObjectRequest.h"
 #include "model/DetectVideoIPCObjectResult.h"
 #include "model/DetectWhiteBaseImageRequest.h"
 #include "model/DetectWhiteBaseImageResult.h"
+#include "model/DetectWorkwearRequest.h"
+#include "model/DetectWorkwearResult.h"
 #include "model/GenerateVehicleRepairPlanRequest.h"
 #include "model/GenerateVehicleRepairPlanResult.h"
 #include "model/GetAsyncJobResultRequest.h"
@@ -69,6 +75,9 @@ namespace AlibabaCloud
 			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::DetectKitchenAnimalsResult> DetectKitchenAnimalsOutcome;
+			typedef std::future<DetectKitchenAnimalsOutcome> DetectKitchenAnimalsOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectKitchenAnimalsRequest&, const DetectKitchenAnimalsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectKitchenAnimalsAsyncHandler;
 			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;
@@ -87,12 +96,18 @@ namespace AlibabaCloud
 			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::DetectVideoFrameResult> DetectVideoFrameOutcome;
+			typedef std::future<DetectVideoFrameOutcome> DetectVideoFrameOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectVideoFrameRequest&, const DetectVideoFrameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVideoFrameAsyncHandler;
 			typedef Outcome<Error, Model::DetectVideoIPCObjectResult> DetectVideoIPCObjectOutcome;
 			typedef std::future<DetectVideoIPCObjectOutcome> DetectVideoIPCObjectOutcomeCallable;
 			typedef std::function<void(const ObjectdetClient*, const Model::DetectVideoIPCObjectRequest&, const DetectVideoIPCObjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVideoIPCObjectAsyncHandler;
 			typedef Outcome<Error, Model::DetectWhiteBaseImageResult> DetectWhiteBaseImageOutcome;
 			typedef std::future<DetectWhiteBaseImageOutcome> DetectWhiteBaseImageOutcomeCallable;
 			typedef std::function<void(const ObjectdetClient*, const Model::DetectWhiteBaseImageRequest&, const DetectWhiteBaseImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectWhiteBaseImageAsyncHandler;
+			typedef Outcome<Error, Model::DetectWorkwearResult> DetectWorkwearOutcome;
+			typedef std::future<DetectWorkwearOutcome> DetectWorkwearOutcomeCallable;
+			typedef std::function<void(const ObjectdetClient*, const Model::DetectWorkwearRequest&, const DetectWorkwearOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectWorkwearAsyncHandler;
 			typedef Outcome<Error, Model::GenerateVehicleRepairPlanResult> GenerateVehicleRepairPlanOutcome;
 			typedef std::future<GenerateVehicleRepairPlanOutcome> GenerateVehicleRepairPlanOutcomeCallable;
 			typedef std::function<void(const ObjectdetClient*, const Model::GenerateVehicleRepairPlanRequest&, const GenerateVehicleRepairPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateVehicleRepairPlanAsyncHandler;
@@ -122,6 +137,9 @@ namespace AlibabaCloud
 			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;
+			DetectKitchenAnimalsOutcome detectKitchenAnimals(const Model::DetectKitchenAnimalsRequest &request)const;
+			void detectKitchenAnimalsAsync(const Model::DetectKitchenAnimalsRequest& request, const DetectKitchenAnimalsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectKitchenAnimalsOutcomeCallable detectKitchenAnimalsCallable(const Model::DetectKitchenAnimalsRequest& 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;
@@ -140,12 +158,18 @@ namespace AlibabaCloud
 			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;
+			DetectVideoFrameOutcome detectVideoFrame(const Model::DetectVideoFrameRequest &request)const;
+			void detectVideoFrameAsync(const Model::DetectVideoFrameRequest& request, const DetectVideoFrameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectVideoFrameOutcomeCallable detectVideoFrameCallable(const Model::DetectVideoFrameRequest& request) const;
 			DetectVideoIPCObjectOutcome detectVideoIPCObject(const Model::DetectVideoIPCObjectRequest &request)const;
 			void detectVideoIPCObjectAsync(const Model::DetectVideoIPCObjectRequest& request, const DetectVideoIPCObjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectVideoIPCObjectOutcomeCallable detectVideoIPCObjectCallable(const Model::DetectVideoIPCObjectRequest& 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;
+			DetectWorkwearOutcome detectWorkwear(const Model::DetectWorkwearRequest &request)const;
+			void detectWorkwearAsync(const Model::DetectWorkwearRequest& request, const DetectWorkwearAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectWorkwearOutcomeCallable detectWorkwearCallable(const Model::DetectWorkwearRequest& request) const;
 			GenerateVehicleRepairPlanOutcome generateVehicleRepairPlan(const Model::GenerateVehicleRepairPlanRequest &request)const;
 			void generateVehicleRepairPlanAsync(const Model::GenerateVehicleRepairPlanRequest& request, const GenerateVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GenerateVehicleRepairPlanOutcomeCallable generateVehicleRepairPlanCallable(const Model::GenerateVehicleRepairPlanRequest& request) const;

objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectRequest.h

@@ -35,10 +35,16 @@ namespace AlibabaCloud
 				DetectIPCObjectRequest();
 				~DetectIPCObjectRequest();
 
+				std::string getOssFile()const;
+				void setOssFile(const std::string& ossFile);
+				std::string getRequestProxyBy()const;
+				void setRequestProxyBy(const std::string& requestProxyBy);
 				std::string getImageURL()const;
 				void setImageURL(const std::string& imageURL);
 
             private:
+				std::string ossFile_;
+				std::string requestProxyBy_;
 				std::string imageURL_;
 
 			};

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

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					struct Element
 					{
 						float targetRate;
-						float score;
 						std::string type;
+						float score;
 						std::vector<std::string> box;
 					};
 					long height;

objectdet/include/alibabacloud/objectdet/model/DetectKitchenAnimalsRequest.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_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_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 DetectKitchenAnimalsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectKitchenAnimalsRequest();
+				~DetectKitchenAnimalsRequest();
+
+				bool getFormatResultToJson()const;
+				void setFormatResultToJson(bool formatResultToJson);
+				std::string getImageURLB()const;
+				void setImageURLB(const std::string& imageURLB);
+				std::string getImageURLA()const;
+				void setImageURLA(const std::string& imageURLA);
+				std::string getOssFile()const;
+				void setOssFile(const std::string& ossFile);
+				std::string getRequestProxyBy()const;
+				void setRequestProxyBy(const std::string& requestProxyBy);
+
+            private:
+				bool formatResultToJson_;
+				std::string imageURLB_;
+				std::string imageURLA_;
+				std::string ossFile_;
+				std::string requestProxyBy_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectKitchenAnimalsResult.h

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

objectdet/include/alibabacloud/objectdet/model/DetectObjectResult.h

@@ -36,8 +36,8 @@ namespace AlibabaCloud
 				{
 					struct Element
 					{
-						float score;
 						std::string type;
+						float score;
 						std::vector<std::string> boxes;
 					};
 					int height;

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

@@ -37,14 +37,20 @@ namespace AlibabaCloud
 
 				Array getRoadRegions()const;
 				void setRoadRegions(const Array& roadRegions);
+				std::string getOriginRequestId()const;
+				void setOriginRequestId(const std::string& originRequestId);
 				Array getPreRegionIntersectFeatures()const;
 				void setPreRegionIntersectFeatures(const Array& preRegionIntersectFeatures);
+				std::string getStreamArn()const;
+				void setStreamArn(const std::string& streamArn);
 				std::string getImageURL()const;
 				void setImageURL(const std::string& imageURL);
 
             private:
 				Array roadRegions_;
+				std::string originRequestId_;
 				Array preRegionIntersectFeatures_;
+				std::string streamArn_;
 				std::string imageURL_;
 
 			};

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

@@ -34,18 +34,6 @@ namespace AlibabaCloud
 			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
@@ -55,14 +43,26 @@ namespace AlibabaCloud
 							long right;
 							long bottom;
 						};
-						std::string typeName;
 						float score;
+						std::string typeName;
 						std::vector<Element::BoxesItem> boxes;
 					};
+					struct RegionIntersectFeaturesItem
+					{
+						std::vector<std::string> features;
+					};
+					struct RegionIntersectMatchedItem
+					{
+						std::vector<std::string> ids;
+					};
+					struct RegionIntersectsItem
+					{
+						std::vector<std::string> ids1;
+					};
 					std::vector<RegionIntersectFeaturesItem> regionIntersectFeatures;
 					std::vector<RegionIntersectsItem> regionIntersects;
-					std::vector<RegionIntersectMatchedItem> regionIntersectMatched;
 					std::vector<Element> elements;
+					std::vector<RegionIntersectMatchedItem> regionIntersectMatched;
 				};
 
 

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

@@ -37,11 +37,17 @@ namespace AlibabaCloud
 
 				Array getRoadRegions()const;
 				void setRoadRegions(const Array& roadRegions);
+				std::string getOriginRequestId()const;
+				void setOriginRequestId(const std::string& originRequestId);
+				std::string getStreamArn()const;
+				void setStreamArn(const std::string& streamArn);
 				std::string getImageURL()const;
 				void setImageURL(const std::string& imageURL);
 
             private:
 				Array roadRegions_;
+				std::string originRequestId_;
+				std::string streamArn_;
 				std::string imageURL_;
 
 			};

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

@@ -34,10 +34,6 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
-					struct RegionIntersect
-					{
-						std::vector<std::string> ids;
-					};
 					struct Element
 					{
 						struct BoxesItem
@@ -47,10 +43,14 @@ namespace AlibabaCloud
 							long right;
 							long bottom;
 						};
-						std::string typeName;
 						float score;
+						std::string typeName;
 						std::vector<Element::BoxesItem> boxes;
 					};
+					struct RegionIntersect
+					{
+						std::vector<std::string> ids;
+					};
 					std::vector<RegionIntersect> regionIntersects;
 					std::vector<Element> elements;
 				};

objectdet/include/alibabacloud/objectdet/model/DetectVideoFrameRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DETECTVIDEOFRAMEREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOFRAMEREQUEST_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 DetectVideoFrameRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectVideoFrameRequest();
+				~DetectVideoFrameRequest();
+
+				Array getFeatures()const;
+				void setFeatures(const Array& features);
+				long getHeight()const;
+				void setHeight(long height);
+				long getCreateTime()const;
+				void setCreateTime(long createTime);
+				std::string getFeatureConfig()const;
+				void setFeatureConfig(const std::string& featureConfig);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getStreamArn()const;
+				void setStreamArn(const std::string& streamArn);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+				long getWidth()const;
+				void setWidth(long width);
+
+            private:
+				Array features_;
+				long height_;
+				long createTime_;
+				std::string featureConfig_;
+				long ownerId_;
+				std::string streamArn_;
+				std::string imageURL_;
+				long width_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOFRAMEREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectVideoFrameResult.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_OBJECTDET_MODEL_DETECTVIDEOFRAMERESULT_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOFRAMERESULT_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 DetectVideoFrameResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string requestId;
+				};
+
+
+				DetectVideoFrameResult();
+				explicit DetectVideoFrameResult(const std::string &payload);
+				~DetectVideoFrameResult();
+				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_DETECTVIDEOFRAMERESULT_H_

objectdet/include/alibabacloud/objectdet/model/DetectVideoIPCObjectRequest.h

@@ -35,12 +35,24 @@ namespace AlibabaCloud
 				DetectVideoIPCObjectRequest();
 				~DetectVideoIPCObjectRequest();
 
+				long getStartTimestamp()const;
+				void setStartTimestamp(long startTimestamp);
+				std::string getOssFile()const;
+				void setOssFile(const std::string& ossFile);
+				bool getCallbackOnlyHasObject()const;
+				void setCallbackOnlyHasObject(bool callbackOnlyHasObject);
+				std::string getRequestProxyBy()const;
+				void setRequestProxyBy(const std::string& requestProxyBy);
 				bool getAsync()const;
 				void setAsync(bool async);
 				std::string getVideoURL()const;
 				void setVideoURL(const std::string& videoURL);
 
             private:
+				long startTimestamp_;
+				std::string ossFile_;
+				bool callbackOnlyHasObject_;
+				std::string requestProxyBy_;
 				bool async_;
 				std::string videoURL_;
 

objectdet/include/alibabacloud/objectdet/model/DetectVideoIPCObjectResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					{
 						struct ElementsItem
 						{
-							float score;
 							std::string type;
+							float score;
 							long x;
 							long y;
 							long height;

objectdet/include/alibabacloud/objectdet/model/DetectWorkwearRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_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 DetectWorkwearRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectWorkwearRequest();
+				~DetectWorkwearRequest();
+
+				bool getFormatResultToJson()const;
+				void setFormatResultToJson(bool formatResultToJson);
+				std::string getOssFile()const;
+				void setOssFile(const std::string& ossFile);
+				std::string getRequestProxyBy()const;
+				void setRequestProxyBy(const std::string& requestProxyBy);
+				Struct getClothes()const;
+				void setClothes(const Struct& clothes);
+				std::vector<std::string> getLabels()const;
+				void setLabels(const std::vector<std::string>& labels);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+
+            private:
+				bool formatResultToJson_;
+				std::string ossFile_;
+				std::string requestProxyBy_;
+				Struct clothes_;
+				std::vector<std::string> labels_;
+				std::string imageUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_H_

objectdet/include/alibabacloud/objectdet/model/DetectWorkwearResult.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DETECTWORKWEARRESULT_H_
+#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARRESULT_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 DetectWorkwearResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct 识别内容
+					{
+						struct Rectangles
+						{
+							long left;
+							long top;
+							long height;
+							long width;
+						};
+						struct 识别属性
+						{
+							struct Probability
+							{
+								double no;
+								double unknown;
+								double yes;
+								long threshold;
+							};
+							Probability probability;
+							std::string label;
+						};
+						double score;
+						std::string type;
+						Rectangles rectangles;
+						std::vector<识别内容::识别属性> property;
+					};
+					std::vector<识别内容> elements;
+				};
+
+
+				DetectWorkwearResult();
+				explicit DetectWorkwearResult(const std::string &payload);
+				~DetectWorkwearResult();
+				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_DETECTWORKWEARRESULT_H_

objectdet/include/alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h

@@ -40,8 +40,8 @@ namespace AlibabaCloud
 						std::string partsStdCode;
 						std::string outStandardPartsName;
 						std::string repairType;
-						std::string repairFee;
 						std::string relationType;
+						std::string repairFee;
 						std::string garageType;
 						std::string partsStdName;
 						std::string outStandardPartsId;

objectdet/src/ObjectdetClient.cc

@@ -31,21 +31,21 @@ ObjectdetClient::ObjectdetClient(const Credentials &credentials, const ClientCon
 	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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
 }
 
 ObjectdetClient::ObjectdetClient(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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
 }
 
 ObjectdetClient::ObjectdetClient(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, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "objectdet");
 }
 
 ObjectdetClient::~ObjectdetClient()
@@ -123,6 +123,42 @@ ObjectdetClient::DetectIPCObjectOutcomeCallable ObjectdetClient::detectIPCObject
 	return task->get_future();
 }
 
+ObjectdetClient::DetectKitchenAnimalsOutcome ObjectdetClient::detectKitchenAnimals(const DetectKitchenAnimalsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectKitchenAnimalsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectKitchenAnimalsOutcome(DetectKitchenAnimalsResult(outcome.result()));
+	else
+		return DetectKitchenAnimalsOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectKitchenAnimalsAsync(const DetectKitchenAnimalsRequest& request, const DetectKitchenAnimalsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectKitchenAnimals(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectKitchenAnimalsOutcomeCallable ObjectdetClient::detectKitchenAnimalsCallable(const DetectKitchenAnimalsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectKitchenAnimalsOutcome()>>(
+			[this, request]()
+			{
+			return this->detectKitchenAnimals(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ObjectdetClient::DetectMainBodyOutcome ObjectdetClient::detectMainBody(const DetectMainBodyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +375,42 @@ ObjectdetClient::DetectVehicleIllegalParkingOutcomeCallable ObjectdetClient::det
 	return task->get_future();
 }
 
+ObjectdetClient::DetectVideoFrameOutcome ObjectdetClient::detectVideoFrame(const DetectVideoFrameRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectVideoFrameOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectVideoFrameOutcome(DetectVideoFrameResult(outcome.result()));
+	else
+		return DetectVideoFrameOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectVideoFrameAsync(const DetectVideoFrameRequest& request, const DetectVideoFrameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectVideoFrame(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectVideoFrameOutcomeCallable ObjectdetClient::detectVideoFrameCallable(const DetectVideoFrameRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectVideoFrameOutcome()>>(
+			[this, request]()
+			{
+			return this->detectVideoFrame(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ObjectdetClient::DetectVideoIPCObjectOutcome ObjectdetClient::detectVideoIPCObject(const DetectVideoIPCObjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +483,42 @@ ObjectdetClient::DetectWhiteBaseImageOutcomeCallable ObjectdetClient::detectWhit
 	return task->get_future();
 }
 
+ObjectdetClient::DetectWorkwearOutcome ObjectdetClient::detectWorkwear(const DetectWorkwearRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectWorkwearOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectWorkwearOutcome(DetectWorkwearResult(outcome.result()));
+	else
+		return DetectWorkwearOutcome(outcome.error());
+}
+
+void ObjectdetClient::detectWorkwearAsync(const DetectWorkwearRequest& request, const DetectWorkwearAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectWorkwear(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ObjectdetClient::DetectWorkwearOutcomeCallable ObjectdetClient::detectWorkwearCallable(const DetectWorkwearRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectWorkwearOutcome()>>(
+			[this, request]()
+			{
+			return this->detectWorkwear(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ObjectdetClient::GenerateVehicleRepairPlanOutcome ObjectdetClient::generateVehicleRepairPlan(const GenerateVehicleRepairPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

objectdet/src/model/DetectIPCObjectRequest.cc

@@ -27,6 +27,28 @@ DetectIPCObjectRequest::DetectIPCObjectRequest() :
 DetectIPCObjectRequest::~DetectIPCObjectRequest()
 {}
 
+std::string DetectIPCObjectRequest::getOssFile()const
+{
+	return ossFile_;
+}
+
+void DetectIPCObjectRequest::setOssFile(const std::string& ossFile)
+{
+	ossFile_ = ossFile;
+	setParameter("OssFile", ossFile);
+}
+
+std::string DetectIPCObjectRequest::getRequestProxyBy()const
+{
+	return requestProxyBy_;
+}
+
+void DetectIPCObjectRequest::setRequestProxyBy(const std::string& requestProxyBy)
+{
+	requestProxyBy_ = requestProxyBy;
+	setParameter("RequestProxyBy", requestProxyBy);
+}
+
 std::string DetectIPCObjectRequest::getImageURL()const
 {
 	return imageURL_;

objectdet/src/model/DetectIPCObjectResult.cc

@@ -40,29 +40,29 @@ void DetectIPCObjectResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Height"].isNull())
-		data_.height = std::stol(dataNode["Height"].asString());
 	if(!dataNode["Width"].isNull())
 		data_.width = std::stol(dataNode["Width"].asString());
+	if(!dataNode["Height"].isNull())
+		data_.height = std::stol(dataNode["Height"].asString());
 	auto allElementsNode = dataNode["Elements"]["Element"];
 	for (auto dataNodeElementsElement : allElementsNode)
 	{
 		Data::Element elementObject;
-		if(!dataNodeElementsElement["TargetRate"].isNull())
-			elementObject.targetRate = std::stof(dataNodeElementsElement["TargetRate"].asString());
-		if(!dataNodeElementsElement["Score"].isNull())
-			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
 		if(!dataNodeElementsElement["Type"].isNull())
 			elementObject.type = dataNodeElementsElement["Type"].asString();
+		if(!dataNodeElementsElement["Score"].isNull())
+			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
+		if(!dataNodeElementsElement["TargetRate"].isNull())
+			elementObject.targetRate = std::stof(dataNodeElementsElement["TargetRate"].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();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

objectdet/src/model/DetectKitchenAnimalsRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DetectKitchenAnimalsRequest.h>
+
+using AlibabaCloud::Objectdet::Model::DetectKitchenAnimalsRequest;
+
+DetectKitchenAnimalsRequest::DetectKitchenAnimalsRequest() :
+	RpcServiceRequest("objectdet", "2019-12-30", "DetectKitchenAnimals")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectKitchenAnimalsRequest::~DetectKitchenAnimalsRequest()
+{}
+
+bool DetectKitchenAnimalsRequest::getFormatResultToJson()const
+{
+	return formatResultToJson_;
+}
+
+void DetectKitchenAnimalsRequest::setFormatResultToJson(bool formatResultToJson)
+{
+	formatResultToJson_ = formatResultToJson;
+	setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
+}
+
+std::string DetectKitchenAnimalsRequest::getImageURLB()const
+{
+	return imageURLB_;
+}
+
+void DetectKitchenAnimalsRequest::setImageURLB(const std::string& imageURLB)
+{
+	imageURLB_ = imageURLB;
+	setBodyParameter("ImageURLB", imageURLB);
+}
+
+std::string DetectKitchenAnimalsRequest::getImageURLA()const
+{
+	return imageURLA_;
+}
+
+void DetectKitchenAnimalsRequest::setImageURLA(const std::string& imageURLA)
+{
+	imageURLA_ = imageURLA;
+	setBodyParameter("ImageURLA", imageURLA);
+}
+
+std::string DetectKitchenAnimalsRequest::getOssFile()const
+{
+	return ossFile_;
+}
+
+void DetectKitchenAnimalsRequest::setOssFile(const std::string& ossFile)
+{
+	ossFile_ = ossFile;
+	setParameter("OssFile", ossFile);
+}
+
+std::string DetectKitchenAnimalsRequest::getRequestProxyBy()const
+{
+	return requestProxyBy_;
+}
+
+void DetectKitchenAnimalsRequest::setRequestProxyBy(const std::string& requestProxyBy)
+{
+	requestProxyBy_ = requestProxyBy;
+	setParameter("RequestProxyBy", requestProxyBy);
+}
+

objectdet/src/model/DetectKitchenAnimalsResult.cc

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

objectdet/src/model/DetectMainBodyResult.cc

@@ -45,10 +45,10 @@ void DetectMainBodyResult::parse(const std::string &payload)
 		data_.location.x = std::stoi(locationNode["X"].asString());
 	if(!locationNode["Y"].isNull())
 		data_.location.y = std::stoi(locationNode["Y"].asString());
-	if(!locationNode["Height"].isNull())
-		data_.location.height = std::stoi(locationNode["Height"].asString());
 	if(!locationNode["Width"].isNull())
 		data_.location.width = std::stoi(locationNode["Width"].asString());
+	if(!locationNode["Height"].isNull())
+		data_.location.height = std::stoi(locationNode["Height"].asString());
 
 }
 

objectdet/src/model/DetectObjectResult.cc

@@ -40,18 +40,18 @@ void DetectObjectResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Height"].isNull())
-		data_.height = std::stoi(dataNode["Height"].asString());
 	if(!dataNode["Width"].isNull())
 		data_.width = std::stoi(dataNode["Width"].asString());
+	if(!dataNode["Height"].isNull())
+		data_.height = std::stoi(dataNode["Height"].asString());
 	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();
+		if(!dataNodeElementsElement["Score"].isNull())
+			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
 		auto allBoxes = value["Boxes"]["Box"];
 		for (auto value : allBoxes)
 			elementObject.boxes.push_back(value.asString());

objectdet/src/model/DetectVehicleICongestionRequest.cc

@@ -35,28 +35,18 @@ Array DetectVehicleICongestionRequest::getRoadRegions()const
 void DetectVehicleICongestionRequest::setRoadRegions(const Array& roadRegions)
 {
 	roadRegions_ = roadRegions;
-	for(int dep1 = 0; dep1!= roadRegions.size(); dep1++) {
-		auto roadRegionsObj = roadRegions.at(dep1);
-		std::string roadRegionsObjStr = "RoadRegions." + std::to_string(dep1 + 1);
-		for(int dep2 = 0; dep2!= roadRegionsObj.roadRegions.size(); dep2++) {
-			auto roadRegionsObj = roadRegionsObj.roadRegions.at(dep2);
-			std::string roadRegionsObjStr = roadRegionsObjStr + "RoadRegions." + std::to_string(dep2 + 1);
-			for(int dep3 = 0; dep3!= roadRegionsObj.roadRegion.size(); dep3++) {
-				auto roadRegionObj = roadRegionsObj.roadRegion.at(dep3);
-				std::string roadRegionObjStr = roadRegionsObjStr + "RoadRegion." + std::to_string(dep3 + 1);
-				for(int dep4 = 0; dep4!= roadRegionObj.roadRegionItem.size(); dep4++) {
-					auto roadRegionItemObj = roadRegionObj.roadRegionItem.at(dep4);
-					std::string roadRegionItemObjStr = roadRegionObjStr + "RoadRegionItem." + std::to_string(dep4 + 1);
-					for(int dep5 = 0; dep5!= roadRegionItemObj.point.size(); dep5++) {
-						auto pointObj = roadRegionItemObj.point.at(dep5);
-						std::string pointObjStr = roadRegionItemObjStr + "Point." + std::to_string(dep5 + 1);
-						setParameter(pointObjStr + ".X", std::to_string(pointObj.x));
-						setParameter(pointObjStr + ".Y", std::to_string(pointObj.y));
-					}
-				}
-			}
-		}
-	}
+	setBodyParameter("RoadRegions", std::to_string(roadRegions));
+}
+
+std::string DetectVehicleICongestionRequest::getOriginRequestId()const
+{
+	return originRequestId_;
+}
+
+void DetectVehicleICongestionRequest::setOriginRequestId(const std::string& originRequestId)
+{
+	originRequestId_ = originRequestId;
+	setParameter("OriginRequestId", originRequestId);
 }
 
 Array DetectVehicleICongestionRequest::getPreRegionIntersectFeatures()const
@@ -67,19 +57,18 @@ Array DetectVehicleICongestionRequest::getPreRegionIntersectFeatures()const
 void DetectVehicleICongestionRequest::setPreRegionIntersectFeatures(const Array& preRegionIntersectFeatures)
 {
 	preRegionIntersectFeatures_ = preRegionIntersectFeatures;
-	for(int dep1 = 0; dep1!= preRegionIntersectFeatures.size(); dep1++) {
-		auto preRegionIntersectFeaturesObj = preRegionIntersectFeatures.at(dep1);
-		std::string preRegionIntersectFeaturesObjStr = "PreRegionIntersectFeatures." + std::to_string(dep1 + 1);
-		for(int dep2 = 0; dep2!= preRegionIntersectFeaturesObj.preRegionIntersectFeatures.size(); dep2++) {
-			auto preRegionIntersectFeaturesObj = preRegionIntersectFeaturesObj.preRegionIntersectFeatures.at(dep2);
-			std::string preRegionIntersectFeaturesObjStr = preRegionIntersectFeaturesObjStr + "PreRegionIntersectFeatures." + std::to_string(dep2 + 1);
-			for(int dep3 = 0; dep3!= preRegionIntersectFeaturesObj.features.size(); dep3++) {
-				auto featuresObj = preRegionIntersectFeaturesObj.features.at(dep3);
-				std::string featuresObjStr = preRegionIntersectFeaturesObjStr + "Features." + std::to_string(dep3 + 1);
-				setParameter(featuresObjStr + ".String", featuresObj.string);
-			}
-		}
-	}
+	setBodyParameter("PreRegionIntersectFeatures", std::to_string(preRegionIntersectFeatures));
+}
+
+std::string DetectVehicleICongestionRequest::getStreamArn()const
+{
+	return streamArn_;
+}
+
+void DetectVehicleICongestionRequest::setStreamArn(const std::string& streamArn)
+{
+	streamArn_ = streamArn;
+	setParameter("StreamArn", streamArn);
 }
 
 std::string DetectVehicleICongestionRequest::getImageURL()const

objectdet/src/model/DetectVehicleICongestionResult.cc

@@ -40,41 +40,14 @@ void DetectVehicleICongestionResult::parse(const std::string &payload)
 	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());
+		if(!dataNodeElementsElement["TypeName"].isNull())
+			elementObject.typeName = dataNodeElementsElement["TypeName"].asString();
 		auto allBoxesNode = dataNodeElementsElement["Boxes"]["BoxesItem"];
 		for (auto dataNodeElementsElementBoxesBoxesItem : allBoxesNode)
 		{
@@ -91,10 +64,37 @@ void DetectVehicleICongestionResult::parse(const std::string &payload)
 		}
 		data_.elements.push_back(elementObject);
 	}
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
+	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 allRegionIntersectMatchedNode = dataNode["RegionIntersectMatched"]["RegionIntersectMatchedItem"];
+	for (auto dataNodeRegionIntersectMatchedRegionIntersectMatchedItem : allRegionIntersectMatchedNode)
+	{
+		Data::RegionIntersectMatchedItem regionIntersectMatchedItemObject;
+		auto allIds = value["Ids"]["Ids"];
+		for (auto value : allIds)
+			regionIntersectMatchedItemObject.ids.push_back(value.asString());
+		data_.regionIntersectMatched.push_back(regionIntersectMatchedItemObject);
+	}
+	auto allRegionIntersectsNode = dataNode["RegionIntersects"]["RegionIntersectsItem"];
+	for (auto dataNodeRegionIntersectsRegionIntersectsItem : allRegionIntersectsNode)
+	{
+		Data::RegionIntersectsItem regionIntersectsItemObject;
+		auto allIds1 = value["Ids"]["Ids"];
+		for (auto value : allIds1)
+			regionIntersectsItemObject.ids1.push_back(value.asString());
+		data_.regionIntersects.push_back(regionIntersectsItemObject);
+	}
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

objectdet/src/model/DetectVehicleIllegalParkingRequest.cc

@@ -35,28 +35,29 @@ Array DetectVehicleIllegalParkingRequest::getRoadRegions()const
 void DetectVehicleIllegalParkingRequest::setRoadRegions(const Array& roadRegions)
 {
 	roadRegions_ = roadRegions;
-	for(int dep1 = 0; dep1!= roadRegions.size(); dep1++) {
-		auto roadRegionsObj = roadRegions.at(dep1);
-		std::string roadRegionsObjStr = "RoadRegions." + std::to_string(dep1 + 1);
-		for(int dep2 = 0; dep2!= roadRegionsObj.roadRegions.size(); dep2++) {
-			auto roadRegionsObj = roadRegionsObj.roadRegions.at(dep2);
-			std::string roadRegionsObjStr = roadRegionsObjStr + "RoadRegions." + std::to_string(dep2 + 1);
-			for(int dep3 = 0; dep3!= roadRegionsObj.roadRegion.size(); dep3++) {
-				auto roadRegionObj = roadRegionsObj.roadRegion.at(dep3);
-				std::string roadRegionObjStr = roadRegionsObjStr + "RoadRegion." + std::to_string(dep3 + 1);
-				for(int dep4 = 0; dep4!= roadRegionObj.roadRegionItem.size(); dep4++) {
-					auto roadRegionItemObj = roadRegionObj.roadRegionItem.at(dep4);
-					std::string roadRegionItemObjStr = roadRegionObjStr + "RoadRegionItem." + std::to_string(dep4 + 1);
-					for(int dep5 = 0; dep5!= roadRegionItemObj.point.size(); dep5++) {
-						auto pointObj = roadRegionItemObj.point.at(dep5);
-						std::string pointObjStr = roadRegionItemObjStr + "Point." + std::to_string(dep5 + 1);
-						setParameter(pointObjStr + ".X", std::to_string(pointObj.x));
-						setParameter(pointObjStr + ".Y", std::to_string(pointObj.y));
-					}
-				}
-			}
-		}
-	}
+	setBodyParameter("RoadRegions", std::to_string(roadRegions));
+}
+
+std::string DetectVehicleIllegalParkingRequest::getOriginRequestId()const
+{
+	return originRequestId_;
+}
+
+void DetectVehicleIllegalParkingRequest::setOriginRequestId(const std::string& originRequestId)
+{
+	originRequestId_ = originRequestId;
+	setParameter("OriginRequestId", originRequestId);
+}
+
+std::string DetectVehicleIllegalParkingRequest::getStreamArn()const
+{
+	return streamArn_;
+}
+
+void DetectVehicleIllegalParkingRequest::setStreamArn(const std::string& streamArn)
+{
+	streamArn_ = streamArn;
+	setParameter("StreamArn", streamArn);
 }
 
 std::string DetectVehicleIllegalParkingRequest::getImageURL()const

objectdet/src/model/DetectVehicleIllegalParkingResult.cc

@@ -40,23 +40,14 @@ void DetectVehicleIllegalParkingResult::parse(const std::string &payload)
 	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());
+		if(!dataNodeElementsElement["TypeName"].isNull())
+			elementObject.typeName = dataNodeElementsElement["TypeName"].asString();
 		auto allBoxesNode = dataNodeElementsElement["Boxes"]["BoxesItem"];
 		for (auto dataNodeElementsElementBoxesBoxesItem : allBoxesNode)
 		{
@@ -73,10 +64,19 @@ void DetectVehicleIllegalParkingResult::parse(const std::string &payload)
 		}
 		data_.elements.push_back(elementObject);
 	}
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
+	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);
+	}
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

objectdet/src/model/DetectVehicleResult.cc

@@ -40,10 +40,10 @@ void DetectVehicleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Height"].isNull())
-		data_.height = std::stoi(dataNode["Height"].asString());
 	if(!dataNode["Width"].isNull())
 		data_.width = std::stoi(dataNode["Width"].asString());
+	if(!dataNode["Height"].isNull())
+		data_.height = std::stoi(dataNode["Height"].asString());
 	auto allDetectObjectInfoListNode = dataNode["DetectObjectInfoList"]["DetectObjectInfo"];
 	for (auto dataNodeDetectObjectInfoListDetectObjectInfo : allDetectObjectInfoListNode)
 	{

objectdet/src/model/DetectVideoFrameRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DetectVideoFrameRequest.h>
+
+using AlibabaCloud::Objectdet::Model::DetectVideoFrameRequest;
+
+DetectVideoFrameRequest::DetectVideoFrameRequest() :
+	RpcServiceRequest("objectdet", "2019-12-30", "DetectVideoFrame")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectVideoFrameRequest::~DetectVideoFrameRequest()
+{}
+
+Array DetectVideoFrameRequest::getFeatures()const
+{
+	return features_;
+}
+
+void DetectVideoFrameRequest::setFeatures(const Array& features)
+{
+	features_ = features;
+	setBodyParameter("Features", std::to_string(features));
+}
+
+long DetectVideoFrameRequest::getHeight()const
+{
+	return height_;
+}
+
+void DetectVideoFrameRequest::setHeight(long height)
+{
+	height_ = height;
+	setBodyParameter("Height", std::to_string(height));
+}
+
+long DetectVideoFrameRequest::getCreateTime()const
+{
+	return createTime_;
+}
+
+void DetectVideoFrameRequest::setCreateTime(long createTime)
+{
+	createTime_ = createTime;
+	setBodyParameter("CreateTime", std::to_string(createTime));
+}
+
+std::string DetectVideoFrameRequest::getFeatureConfig()const
+{
+	return featureConfig_;
+}
+
+void DetectVideoFrameRequest::setFeatureConfig(const std::string& featureConfig)
+{
+	featureConfig_ = featureConfig;
+	setBodyParameter("FeatureConfig", featureConfig);
+}
+
+long DetectVideoFrameRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DetectVideoFrameRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setBodyParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DetectVideoFrameRequest::getStreamArn()const
+{
+	return streamArn_;
+}
+
+void DetectVideoFrameRequest::setStreamArn(const std::string& streamArn)
+{
+	streamArn_ = streamArn;
+	setBodyParameter("StreamArn", streamArn);
+}
+
+std::string DetectVideoFrameRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void DetectVideoFrameRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+
+long DetectVideoFrameRequest::getWidth()const
+{
+	return width_;
+}
+
+void DetectVideoFrameRequest::setWidth(long width)
+{
+	width_ = width;
+	setBodyParameter("Width", std::to_string(width));
+}
+

objectdet/src/model/DetectVideoFrameResult.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/objectdet/model/DetectVideoFrameResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Objectdet;
+using namespace AlibabaCloud::Objectdet::Model;
+
+DetectVideoFrameResult::DetectVideoFrameResult() :
+	ServiceResult()
+{}
+
+DetectVideoFrameResult::DetectVideoFrameResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectVideoFrameResult::~DetectVideoFrameResult()
+{}
+
+void DetectVideoFrameResult::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["RequestId"].isNull())
+		data_.requestId = dataNode["RequestId"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DetectVideoFrameResult::getMessage()const
+{
+	return message_;
+}
+
+DetectVideoFrameResult::Data DetectVideoFrameResult::getData()const
+{
+	return data_;
+}
+
+std::string DetectVideoFrameResult::getCode()const
+{
+	return code_;
+}
+

objectdet/src/model/DetectVideoIPCObjectRequest.cc

@@ -27,6 +27,50 @@ DetectVideoIPCObjectRequest::DetectVideoIPCObjectRequest() :
 DetectVideoIPCObjectRequest::~DetectVideoIPCObjectRequest()
 {}
 
+long DetectVideoIPCObjectRequest::getStartTimestamp()const
+{
+	return startTimestamp_;
+}
+
+void DetectVideoIPCObjectRequest::setStartTimestamp(long startTimestamp)
+{
+	startTimestamp_ = startTimestamp;
+	setBodyParameter("StartTimestamp", std::to_string(startTimestamp));
+}
+
+std::string DetectVideoIPCObjectRequest::getOssFile()const
+{
+	return ossFile_;
+}
+
+void DetectVideoIPCObjectRequest::setOssFile(const std::string& ossFile)
+{
+	ossFile_ = ossFile;
+	setParameter("OssFile", ossFile);
+}
+
+bool DetectVideoIPCObjectRequest::getCallbackOnlyHasObject()const
+{
+	return callbackOnlyHasObject_;
+}
+
+void DetectVideoIPCObjectRequest::setCallbackOnlyHasObject(bool callbackOnlyHasObject)
+{
+	callbackOnlyHasObject_ = callbackOnlyHasObject;
+	setBodyParameter("CallbackOnlyHasObject", callbackOnlyHasObject ? "true" : "false");
+}
+
+std::string DetectVideoIPCObjectRequest::getRequestProxyBy()const
+{
+	return requestProxyBy_;
+}
+
+void DetectVideoIPCObjectRequest::setRequestProxyBy(const std::string& requestProxyBy)
+{
+	requestProxyBy_ = requestProxyBy;
+	setParameter("RequestProxyBy", requestProxyBy);
+}
+
 bool DetectVideoIPCObjectRequest::getAsync()const
 {
 	return async_;

objectdet/src/model/DetectVideoIPCObjectResult.cc

@@ -40,10 +40,10 @@ void DetectVideoIPCObjectResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Height"].isNull())
-		data_.height = std::stol(dataNode["Height"].asString());
 	if(!dataNode["Width"].isNull())
 		data_.width = std::stol(dataNode["Width"].asString());
+	if(!dataNode["Height"].isNull())
+		data_.height = std::stol(dataNode["Height"].asString());
 	if(!dataNode["InputFile"].isNull())
 		data_.inputFile = dataNode["InputFile"].asString();
 	auto allFramesNode = dataNode["Frames"]["Frame"];
@@ -56,26 +56,26 @@ void DetectVideoIPCObjectResult::parse(const std::string &payload)
 		for (auto dataNodeFramesFrameElementselementsItem : allElementsNode)
 		{
 			Data::Frame::ElementsItem elementsObject;
-			if(!dataNodeFramesFrameElementselementsItem["Score"].isNull())
-				elementsObject.score = std::stof(dataNodeFramesFrameElementselementsItem["Score"].asString());
 			if(!dataNodeFramesFrameElementselementsItem["Type"].isNull())
 				elementsObject.type = dataNodeFramesFrameElementselementsItem["Type"].asString();
 			if(!dataNodeFramesFrameElementselementsItem["X"].isNull())
 				elementsObject.x = std::stol(dataNodeFramesFrameElementselementsItem["X"].asString());
 			if(!dataNodeFramesFrameElementselementsItem["Y"].isNull())
 				elementsObject.y = std::stol(dataNodeFramesFrameElementselementsItem["Y"].asString());
-			if(!dataNodeFramesFrameElementselementsItem["Height"].isNull())
-				elementsObject.height = std::stol(dataNodeFramesFrameElementselementsItem["Height"].asString());
 			if(!dataNodeFramesFrameElementselementsItem["Width"].isNull())
 				elementsObject.width = std::stol(dataNodeFramesFrameElementselementsItem["Width"].asString());
+			if(!dataNodeFramesFrameElementselementsItem["Height"].isNull())
+				elementsObject.height = std::stol(dataNodeFramesFrameElementselementsItem["Height"].asString());
+			if(!dataNodeFramesFrameElementselementsItem["Score"].isNull())
+				elementsObject.score = std::stof(dataNodeFramesFrameElementselementsItem["Score"].asString());
 			frameObject.elements.push_back(elementsObject);
 		}
 		data_.frames.push_back(frameObject);
 	}
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

objectdet/src/model/DetectWorkwearRequest.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/DetectWorkwearRequest.h>
+
+using AlibabaCloud::Objectdet::Model::DetectWorkwearRequest;
+
+DetectWorkwearRequest::DetectWorkwearRequest() :
+	RpcServiceRequest("objectdet", "2019-12-30", "DetectWorkwear")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectWorkwearRequest::~DetectWorkwearRequest()
+{}
+
+bool DetectWorkwearRequest::getFormatResultToJson()const
+{
+	return formatResultToJson_;
+}
+
+void DetectWorkwearRequest::setFormatResultToJson(bool formatResultToJson)
+{
+	formatResultToJson_ = formatResultToJson;
+	setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
+}
+
+std::string DetectWorkwearRequest::getOssFile()const
+{
+	return ossFile_;
+}
+
+void DetectWorkwearRequest::setOssFile(const std::string& ossFile)
+{
+	ossFile_ = ossFile;
+	setParameter("OssFile", ossFile);
+}
+
+std::string DetectWorkwearRequest::getRequestProxyBy()const
+{
+	return requestProxyBy_;
+}
+
+void DetectWorkwearRequest::setRequestProxyBy(const std::string& requestProxyBy)
+{
+	requestProxyBy_ = requestProxyBy;
+	setParameter("RequestProxyBy", requestProxyBy);
+}
+
+Struct DetectWorkwearRequest::getClothes()const
+{
+	return clothes_;
+}
+
+void DetectWorkwearRequest::setClothes(const Struct& clothes)
+{
+	clothes_ = clothes;
+	setBodyParameter("Clothes", std::to_string(clothes));
+}
+
+std::vector<std::string> DetectWorkwearRequest::getLabels()const
+{
+	return labels_;
+}
+
+void DetectWorkwearRequest::setLabels(const std::vector<std::string>& labels)
+{
+	labels_ = labels;
+	for(int dep1 = 0; dep1!= labels.size(); dep1++) {
+		setBodyParameter("Labels."+ std::to_string(dep1), labels.at(dep1));
+	}
+}
+
+std::string DetectWorkwearRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void DetectWorkwearRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+

objectdet/src/model/DetectWorkwearResult.cc

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DetectWorkwearResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Objectdet;
+using namespace AlibabaCloud::Objectdet::Model;
+
+DetectWorkwearResult::DetectWorkwearResult() :
+	ServiceResult()
+{}
+
+DetectWorkwearResult::DetectWorkwearResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectWorkwearResult::~DetectWorkwearResult()
+{}
+
+void DetectWorkwearResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allElementsNode = dataNode["Elements"]["识别内容"];
+	for (auto dataNodeElements识别内容 : allElementsNode)
+	{
+		Data::识别内容 识别内容Object;
+		if(!dataNodeElements识别内容["Score"].isNull())
+			识别内容Object.score = dataNodeElements识别内容["Score"].asString();
+		if(!dataNodeElements识别内容["Type"].isNull())
+			识别内容Object.type = dataNodeElements识别内容["Type"].asString();
+		auto allPropertyNode = dataNodeElements识别内容["Property"]["识别属性"];
+		for (auto dataNodeElements识别内容Property识别属性 : allPropertyNode)
+		{
+			Data::识别内容::识别属性 propertyObject;
+			if(!dataNodeElements识别内容Property识别属性["Label"].isNull())
+				propertyObject.label = dataNodeElements识别内容Property识别属性["Label"].asString();
+			auto probabilityNode = value["Probability"];
+			if(!probabilityNode["No"].isNull())
+				propertyObject.probability.no = probabilityNode["No"].asString();
+			if(!probabilityNode["Threshold"].isNull())
+				propertyObject.probability.threshold = std::stol(probabilityNode["Threshold"].asString());
+			if(!probabilityNode["Unknown"].isNull())
+				propertyObject.probability.unknown = probabilityNode["Unknown"].asString();
+			if(!probabilityNode["Yes"].isNull())
+				propertyObject.probability.yes = probabilityNode["Yes"].asString();
+			识别内容Object.property.push_back(propertyObject);
+		}
+		auto rectanglesNode = value["Rectangles"];
+		if(!rectanglesNode["Height"].isNull())
+			识别内容Object.rectangles.height = std::stol(rectanglesNode["Height"].asString());
+		if(!rectanglesNode["Left"].isNull())
+			识别内容Object.rectangles.left = std::stol(rectanglesNode["Left"].asString());
+		if(!rectanglesNode["Top"].isNull())
+			识别内容Object.rectangles.top = std::stol(rectanglesNode["Top"].asString());
+		if(!rectanglesNode["Width"].isNull())
+			识别内容Object.rectangles.width = std::stol(rectanglesNode["Width"].asString());
+		data_.elements.push_back(识别内容Object);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DetectWorkwearResult::getMessage()const
+{
+	return message_;
+}
+
+DetectWorkwearResult::Data DetectWorkwearResult::getData()const
+{
+	return data_;
+}
+
+std::string DetectWorkwearResult::getCode()const
+{
+	return code_;
+}
+

objectdet/src/model/GenerateVehicleRepairPlanResult.cc

@@ -44,10 +44,10 @@ void GenerateVehicleRepairPlanResult::parse(const std::string &payload)
 		data_.taskId = dataNode["TaskId"].asString();
 	if(!value["HttpCode"].isNull())
 		httpCode_ = std::stoi(value["HttpCode"].asString());
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
 

objectdet/src/model/GetVehicleRepairPlanResult.cc

@@ -46,38 +46,38 @@ void GetVehicleRepairPlanResult::parse(const std::string &payload)
 	for (auto dataNodeRepairPartsRepairItems : allRepairPartsNode)
 	{
 		Data::RepairItems repairItemsObject;
+		if(!dataNodeRepairPartsRepairItems["GarageType"].isNull())
+			repairItemsObject.garageType = dataNodeRepairPartsRepairItems["GarageType"].asString();
+		if(!dataNodeRepairPartsRepairItems["OeMatch"].isNull())
+			repairItemsObject.oeMatch = dataNodeRepairPartsRepairItems["OeMatch"].asString() == "true";
+		if(!dataNodeRepairPartsRepairItems["OutStandardPartsId"].isNull())
+			repairItemsObject.outStandardPartsId = dataNodeRepairPartsRepairItems["OutStandardPartsId"].asString();
+		if(!dataNodeRepairPartsRepairItems["OutStandardPartsName"].isNull())
+			repairItemsObject.outStandardPartsName = dataNodeRepairPartsRepairItems["OutStandardPartsName"].asString();
 		if(!dataNodeRepairPartsRepairItems["PartNameMatch"].isNull())
 			repairItemsObject.partNameMatch = dataNodeRepairPartsRepairItems["PartNameMatch"].asString() == "true";
 		if(!dataNodeRepairPartsRepairItems["PartsStdCode"].isNull())
 			repairItemsObject.partsStdCode = dataNodeRepairPartsRepairItems["PartsStdCode"].asString();
-		if(!dataNodeRepairPartsRepairItems["OutStandardPartsName"].isNull())
-			repairItemsObject.outStandardPartsName = dataNodeRepairPartsRepairItems["OutStandardPartsName"].asString();
-		if(!dataNodeRepairPartsRepairItems["RepairType"].isNull())
-			repairItemsObject.repairType = dataNodeRepairPartsRepairItems["RepairType"].asString();
-		if(!dataNodeRepairPartsRepairItems["RepairFee"].isNull())
-			repairItemsObject.repairFee = dataNodeRepairPartsRepairItems["RepairFee"].asString();
-		if(!dataNodeRepairPartsRepairItems["RelationType"].isNull())
-			repairItemsObject.relationType = dataNodeRepairPartsRepairItems["RelationType"].asString();
-		if(!dataNodeRepairPartsRepairItems["GarageType"].isNull())
-			repairItemsObject.garageType = dataNodeRepairPartsRepairItems["GarageType"].asString();
 		if(!dataNodeRepairPartsRepairItems["PartsStdName"].isNull())
 			repairItemsObject.partsStdName = dataNodeRepairPartsRepairItems["PartsStdName"].asString();
-		if(!dataNodeRepairPartsRepairItems["OutStandardPartsId"].isNull())
-			repairItemsObject.outStandardPartsId = dataNodeRepairPartsRepairItems["OutStandardPartsId"].asString();
+		if(!dataNodeRepairPartsRepairItems["RelationType"].isNull())
+			repairItemsObject.relationType = dataNodeRepairPartsRepairItems["RelationType"].asString();
+		if(!dataNodeRepairPartsRepairItems["RepairFee"].isNull())
+			repairItemsObject.repairFee = dataNodeRepairPartsRepairItems["RepairFee"].asString();
+		if(!dataNodeRepairPartsRepairItems["RepairType"].isNull())
+			repairItemsObject.repairType = dataNodeRepairPartsRepairItems["RepairType"].asString();
 		if(!dataNodeRepairPartsRepairItems["RepairTypeName"].isNull())
 			repairItemsObject.repairTypeName = dataNodeRepairPartsRepairItems["RepairTypeName"].asString();
-		if(!dataNodeRepairPartsRepairItems["OeMatch"].isNull())
-			repairItemsObject.oeMatch = dataNodeRepairPartsRepairItems["OeMatch"].asString() == "true";
 		data_.repairParts.push_back(repairItemsObject);
 	}
-	if(!value["HttpCode"].isNull())
-		httpCode_ = std::stoi(value["HttpCode"].asString());
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
+	if(!value["HttpCode"].isNull())
+		httpCode_ = std::stoi(value["HttpCode"].asString());
 
 }