1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release DetectVehicleIllegalParking DetectVehicleICongestion.

Browse Source
This commit is contained in:
sdk-team
2021-02-01 02:22:23 +00:00
parent 4b58532ad0
commit e0575e4c67
16 changed files with 971 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
objectdet/include/alibabacloud/objectdet/ObjectdetClient.h
View File

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

48
objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectRequest.h Normal file
View File

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

65
objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectResult.h Normal file
View File

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

54
objectdet/include/alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h Normal file
View File

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

87
objectdet/include/alibabacloud/objectdet/model/DetectVehicleICongestionResult.h Normal file
View File

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

51
objectdet/include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h Normal file
View File

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

77
objectdet/include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingResult.h Normal file
View File

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