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

Update DetectVehicleICongestion DetectVehicleIllegalParking.

Browse Source
This commit is contained in:
sdk-team
2022-12-15 06:10:57 +00:00
parent 3766be3d58
commit 2a254b88e0
49 changed files with 1433 additions and 2550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1389
1.36.1390

12
objectdet/CMakeLists.txt
View File

@@ -39,20 +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
include/alibabacloud/objectdet/model/GetAsyncJobResultResult.h
include/alibabacloud/objectdet/model/GetVehicleRepairPlanRequest.h
include/alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h
include/alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h
include/alibabacloud/objectdet/model/RecognizeVehicleDamageResult.h
include/alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h
@@ -80,20 +74,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
src/model/GetAsyncJobResultResult.cc
src/model/GetVehicleRepairPlanRequest.cc
src/model/GetVehicleRepairPlanResult.cc
src/model/RecognizeVehicleDamageRequest.cc
src/model/RecognizeVehicleDamageResult.cc
src/model/RecognizeVehicleDashboardRequest.cc

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

@@ -40,20 +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"
#include "model/GetAsyncJobResultResult.h"
#include "model/GetVehicleRepairPlanRequest.h"
#include "model/GetVehicleRepairPlanResult.h"
#include "model/RecognizeVehicleDamageRequest.h"
#include "model/RecognizeVehicleDamageResult.h"
#include "model/RecognizeVehicleDashboardRequest.h"
@@ -96,9 +90,6 @@ 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;
@@ -108,15 +99,9 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::GetVehicleRepairPlanResult> GetVehicleRepairPlanOutcome;
typedef std::future<GetVehicleRepairPlanOutcome> GetVehicleRepairPlanOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::GetVehicleRepairPlanRequest&, const GetVehicleRepairPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVehicleRepairPlanAsyncHandler;
typedef Outcome<Error, Model::RecognizeVehicleDamageResult> RecognizeVehicleDamageOutcome;
typedef std::future<RecognizeVehicleDamageOutcome> RecognizeVehicleDamageOutcomeCallable;
typedef std::function<void(const ObjectdetClient*, const Model::RecognizeVehicleDamageRequest&, const RecognizeVehicleDamageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVehicleDamageAsyncHandler;
@@ -158,9 +143,6 @@ 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;
@@ -170,15 +152,9 @@ namespace AlibabaCloud
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;
GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
GetVehicleRepairPlanOutcome getVehicleRepairPlan(const Model::GetVehicleRepairPlanRequest &request)const;
void getVehicleRepairPlanAsync(const Model::GetVehicleRepairPlanRequest& request, const GetVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVehicleRepairPlanOutcomeCallable getVehicleRepairPlanCallable(const Model::GetVehicleRepairPlanRequest& request) const;
RecognizeVehicleDamageOutcome recognizeVehicleDamage(const Model::RecognizeVehicleDamageRequest &request)const;
void recognizeVehicleDamageAsync(const Model::RecognizeVehicleDamageRequest& request, const RecognizeVehicleDamageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVehicleDamageOutcomeCallable recognizeVehicleDamageCallable(const Model::RecognizeVehicleDamageRequest& request) const;

86
objectdet/include/alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h
View File

@@ -1,57 +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_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT ClassifyVehicleInsuranceRequest : public RpcServiceRequest
{
public:
ClassifyVehicleInsuranceRequest();
~ClassifyVehicleInsuranceRequest();
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);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT ClassifyVehicleInsuranceRequest : public RpcServiceRequest {
public:
ClassifyVehicleInsuranceRequest();
~ClassifyVehicleInsuranceRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_CLASSIFYVEHICLEINSURANCEREQUEST_H_

86
objectdet/include/alibabacloud/objectdet/model/DetectIPCObjectRequest.h
View File

@@ -1,57 +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_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();
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);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectIPCObjectRequest : public RpcServiceRequest {
public:
DetectIPCObjectRequest();
~DetectIPCObjectRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTIPCOBJECTREQUEST_H_

92
objectdet/include/alibabacloud/objectdet/model/DetectKitchenAnimalsRequest.h
View File

@@ -1,60 +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_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_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTKITCHENANIMALSREQUEST_H_

77
objectdet/include/alibabacloud/objectdet/model/DetectMainBodyRequest.h
View File

@@ -1,48 +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_DETECTMAINBODYREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectMainBodyRequest : public RpcServiceRequest
{
public:
DetectMainBodyRequest();
~DetectMainBodyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectMainBodyRequest : public RpcServiceRequest {
public:
DetectMainBodyRequest();
~DetectMainBodyRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTMAINBODYREQUEST_H_

77
objectdet/include/alibabacloud/objectdet/model/DetectObjectRequest.h
View File

@@ -1,48 +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_DETECTOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/objectdet/ObjectdetExport.h>
namespace AlibabaCloud
{
namespace Objectdet
{
namespace Model
{
class ALIBABACLOUD_OBJECTDET_EXPORT DetectObjectRequest : public RpcServiceRequest
{
public:
DetectObjectRequest();
~DetectObjectRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectObjectRequest : public RpcServiceRequest {
public:
DetectObjectRequest();
~DetectObjectRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTOBJECTREQUEST_H_

77
objectdet/include/alibabacloud/objectdet/model/DetectTransparentImageRequest.h
View File

@@ -1,48 +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_DETECTTRANSPARENTIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_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 DetectTransparentImageRequest : public RpcServiceRequest
{
public:
DetectTransparentImageRequest();
~DetectTransparentImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectTransparentImageRequest : public RpcServiceRequest {
public:
DetectTransparentImageRequest();
~DetectTransparentImageRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTTRANSPARENTIMAGEREQUEST_H_

125
objectdet/include/alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h
View File

@@ -1,69 +1,78 @@
/*
* 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();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
Array getRoadRegions()const;
void setRoadRegions(const Array& roadRegions);
std::string getOriginRequestId()const;
void setOriginRequestId(const std::string& originRequestId);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
Array getPreRegionIntersectFeatures()const;
void setPreRegionIntersectFeatures(const Array& preRegionIntersectFeatures);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
std::string getStreamArn()const;
void setStreamArn(const std::string& streamArn);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
Array roadRegions_;
std::string originRequestId_;
std::string ossFile_;
Array preRegionIntersectFeatures_;
std::string requestProxyBy_;
std::string streamArn_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVehicleICongestionRequest : public RpcServiceRequest {
public:
struct RoadRegions {
struct RoadRegionItem {
struct Point {
long x;
long y;
};
Point point;
};
RoadRegionItem roadRegionItem;
std::vector<RoadRegionItem> roadRegion;
};
struct PreRegionIntersectFeatures {
std::string string;
std::vector<std::string> features;
};
DetectVehicleICongestionRequest();
~DetectVehicleICongestionRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::vector<RoadRegions> getRoadRegions() const;
void setRoadRegions(const std::vector<RoadRegions> &roadRegions);
std::string getOriginRequestId() const;
void setOriginRequestId(const std::string &originRequestId);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::vector<PreRegionIntersectFeatures> getPreRegionIntersectFeatures() const;
void setPreRegionIntersectFeatures(const std::vector<PreRegionIntersectFeatures> &preRegionIntersectFeatures);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getStreamArn() const;
void setStreamArn(const std::string &streamArn);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::vector<RoadRegions> roadRegions_;
std::string originRequestId_;
std::string ossFile_;
std::vector<PreRegionIntersectFeatures> preRegionIntersectFeatures_;
std::string requestProxyBy_;
std::string streamArn_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEICONGESTIONREQUEST_H_

115
objectdet/include/alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h
View File

@@ -1,66 +1,71 @@
/*
* 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();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
Array getRoadRegions()const;
void setRoadRegions(const Array& roadRegions);
std::string getOriginRequestId()const;
void setOriginRequestId(const std::string& originRequestId);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
std::string getStreamArn()const;
void setStreamArn(const std::string& streamArn);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
Array roadRegions_;
std::string originRequestId_;
std::string ossFile_;
std::string requestProxyBy_;
std::string streamArn_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVehicleIllegalParkingRequest : public RpcServiceRequest {
public:
struct RoadRegions {
struct RoadRegionItem {
struct Point {
long x;
long y;
};
Point point;
};
RoadRegionItem roadRegionItem;
std::vector<RoadRegionItem> roadRegion;
};
DetectVehicleIllegalParkingRequest();
~DetectVehicleIllegalParkingRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::vector<RoadRegions> getRoadRegions() const;
void setRoadRegions(const std::vector<RoadRegions> &roadRegions);
std::string getOriginRequestId() const;
void setOriginRequestId(const std::string &originRequestId);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getStreamArn() const;
void setStreamArn(const std::string &streamArn);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::vector<RoadRegions> roadRegions_;
std::string originRequestId_;
std::string ossFile_;
std::string requestProxyBy_;
std::string streamArn_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEILLEGALPARKINGREQUEST_H_

92
objectdet/include/alibabacloud/objectdet/model/DetectVehicleRequest.h
View File

@@ -1,60 +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_DETECTVEHICLEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_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 DetectVehicleRequest : public RpcServiceRequest
{
public:
DetectVehicleRequest();
~DetectVehicleRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
int getImageType()const;
void setImageType(int imageType);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
int imageType_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVehicleRequest : public RpcServiceRequest {
public:
DetectVehicleRequest();
~DetectVehicleRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
int getImageType() const;
void setImageType(int imageType);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
int imageType_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVEHICLEREQUEST_H_

69
objectdet/include/alibabacloud/objectdet/model/DetectVideoFrameRequest.h
View File

@@ -1,69 +0,0 @@
/*
* 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_

59
objectdet/include/alibabacloud/objectdet/model/DetectVideoFrameResult.h
View File

@@ -1,59 +0,0 @@
/*
* 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_

104
objectdet/include/alibabacloud/objectdet/model/DetectVideoIPCObjectRequest.h
View File

@@ -1,66 +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_DETECTVIDEOIPCOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOIPCOBJECTREQUEST_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 DetectVideoIPCObjectRequest : public RpcServiceRequest
{
public:
DetectVideoIPCObjectRequest();
~DetectVideoIPCObjectRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
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:
bool formatResultToJson_;
long startTimestamp_;
std::string ossFile_;
bool callbackOnlyHasObject_;
std::string requestProxyBy_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOIPCOBJECTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOIPCOBJECTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOIPCOBJECTREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectVideoIPCObjectRequest : public RpcServiceRequest {
public:
DetectVideoIPCObjectRequest();
~DetectVideoIPCObjectRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
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:
bool formatResultToJson_;
long startTimestamp_;
std::string ossFile_;
bool callbackOnlyHasObject_;
std::string requestProxyBy_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTVIDEOIPCOBJECTREQUEST_H_

77
objectdet/include/alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h
View File

@@ -1,48 +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_DETECTWHITEBASEIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_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 DetectWhiteBaseImageRequest : public RpcServiceRequest
{
public:
DetectWhiteBaseImageRequest();
~DetectWhiteBaseImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectWhiteBaseImageRequest : public RpcServiceRequest {
public:
DetectWhiteBaseImageRequest();
~DetectWhiteBaseImageRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWHITEBASEIMAGEREQUEST_H_

102
objectdet/include/alibabacloud/objectdet/model/DetectWorkwearRequest.h
View File

@@ -1,63 +1,61 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT DetectWorkwearRequest : public RpcServiceRequest {
public:
struct Clothes {
double threshold;
long maxNum;
};
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);
Clothes getClothes() const;
void setClothes(const Clothes &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_;
Clothes clothes_;
std::vector<std::string> labels_;
std::string imageUrl_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_DETECTWORKWEARREQUEST_H_

54
objectdet/include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanRequest.h
View File

@@ -1,54 +0,0 @@
/*
* 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_GENERATEVEHICLEREPAIRPLANREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANREQUEST_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 GenerateVehicleRepairPlanRequest : public RpcServiceRequest
{
public:
struct DamageImageList
{
std::string imageUrl;
std::string createTimeStamp;
};
public:
GenerateVehicleRepairPlanRequest();
~GenerateVehicleRepairPlanRequest();
std::vector<DamageImageList> getDamageImageList()const;
void setDamageImageList(const std::vector<DamageImageList>& damageImageList);
private:
std::vector<DamageImageList> damageImageList_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANREQUEST_H_

63
objectdet/include/alibabacloud/objectdet/model/GenerateVehicleRepairPlanResult.h
View File

@@ -1,63 +0,0 @@
/*
* 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_GENERATEVEHICLEREPAIRPLANRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANRESULT_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 GenerateVehicleRepairPlanResult : public ServiceResult
{
public:
struct Data
{
std::string taskId;
};
GenerateVehicleRepairPlanResult();
explicit GenerateVehicleRepairPlanResult(const std::string &payload);
~GenerateVehicleRepairPlanResult();
int getHttpCode()const;
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int httpCode_;
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GENERATEVEHICLEREPAIRPLANRESULT_H_

92
objectdet/include/alibabacloud/objectdet/model/GetAsyncJobResultRequest.h
View File

@@ -1,60 +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_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETASYNCJOBRESULTREQUEST_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 GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
std::string getJobId()const;
void setJobId(const std::string& jobId);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
bool getAsync()const;
void setAsync(bool async);
private:
bool formatResultToJson_;
std::string jobId_;
std::string ossFile_;
std::string requestProxyBy_;
bool async_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETASYNCJOBRESULTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
bool getFormatResultToJson() const;
void setFormatResultToJson(bool formatResultToJson);
std::string getJobId() const;
void setJobId(const std::string &jobId);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
bool getAsync() const;
void setAsync(bool async);
private:
bool formatResultToJson_;
std::string jobId_;
std::string ossFile_;
std::string requestProxyBy_;
bool async_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETASYNCJOBRESULTREQUEST_H_

63
objectdet/include/alibabacloud/objectdet/model/GetVehicleRepairPlanRequest.h
View File

@@ -1,63 +0,0 @@
/*
* 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_GETVEHICLEREPAIRPLANREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANREQUEST_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 GetVehicleRepairPlanRequest : public RpcServiceRequest
{
public:
GetVehicleRepairPlanRequest();
~GetVehicleRepairPlanRequest();
std::string getVinCodeImage()const;
void setVinCodeImage(const std::string& vinCodeImage);
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
std::string getCarNumberImage()const;
void setCarNumberImage(const std::string& carNumberImage);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
private:
std::string vinCodeImage_;
bool formatResultToJson_;
std::string carNumberImage_;
std::string taskId_;
std::string ossFile_;
std::string requestProxyBy_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANREQUEST_H_

78
objectdet/include/alibabacloud/objectdet/model/GetVehicleRepairPlanResult.h
View File

@@ -1,78 +0,0 @@
/*
* 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_GETVEHICLEREPAIRPLANRESULT_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANRESULT_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 GetVehicleRepairPlanResult : public ServiceResult
{
public:
struct Data
{
struct RepairItems
{
bool partNameMatch;
std::string partsStdCode;
std::string outStandardPartsName;
std::string repairType;
std::string relationType;
std::string repairFee;
std::string partsStdName;
std::string garageType;
std::string outStandardPartsId;
std::string repairTypeName;
bool oeMatch;
};
std::string frameNo;
std::vector<RepairItems> repairParts;
};
GetVehicleRepairPlanResult();
explicit GetVehicleRepairPlanResult(const std::string &payload);
~GetVehicleRepairPlanResult();
int getHttpCode()const;
Data getData()const;
std::string getErrorMessage()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
int httpCode_;
Data data_;
std::string errorMessage_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_GETVEHICLEREPAIRPLANRESULT_H_

86
objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h
View File

@@ -1,57 +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_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_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 RecognizeVehicleDamageRequest : public RpcServiceRequest
{
public:
RecognizeVehicleDamageRequest();
~RecognizeVehicleDamageRequest();
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);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDamageRequest : public RpcServiceRequest {
public:
RecognizeVehicleDamageRequest();
~RecognizeVehicleDamageRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDAMAGEREQUEST_H_

86
objectdet/include/alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h
View File

@@ -1,57 +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_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_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 RecognizeVehicleDashboardRequest : public RpcServiceRequest
{
public:
RecognizeVehicleDashboardRequest();
~RecognizeVehicleDashboardRequest();
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);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehicleDashboardRequest : public RpcServiceRequest {
public:
RecognizeVehicleDashboardRequest();
~RecognizeVehicleDashboardRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEDASHBOARDREQUEST_H_

86
objectdet/include/alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h
View File

@@ -1,57 +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_RECOGNIZEVEHICLEPARTSREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_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 RecognizeVehiclePartsRequest : public RpcServiceRequest
{
public:
RecognizeVehiclePartsRequest();
~RecognizeVehiclePartsRequest();
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);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
*/
#ifndef ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
#define ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_
#include <alibabacloud/objectdet/ObjectdetExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Objectdet {
namespace Model {
class ALIBABACLOUD_OBJECTDET_EXPORT RecognizeVehiclePartsRequest : public RpcServiceRequest {
public:
RecognizeVehiclePartsRequest();
~RecognizeVehiclePartsRequest();
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool formatResultToJson_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Objectdet
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OBJECTDET_MODEL_RECOGNIZEVEHICLEPARTSREQUEST_H_

108
objectdet/src/ObjectdetClient.cc
View File

@@ -375,42 +375,6 @@ 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();
@@ -519,42 +483,6 @@ ObjectdetClient::DetectWorkwearOutcomeCallable ObjectdetClient::detectWorkwearCa
return task->get_future();
}
ObjectdetClient::GenerateVehicleRepairPlanOutcome ObjectdetClient::generateVehicleRepairPlan(const GenerateVehicleRepairPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateVehicleRepairPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateVehicleRepairPlanOutcome(GenerateVehicleRepairPlanResult(outcome.result()));
else
return GenerateVehicleRepairPlanOutcome(outcome.error());
}
void ObjectdetClient::generateVehicleRepairPlanAsync(const GenerateVehicleRepairPlanRequest& request, const GenerateVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateVehicleRepairPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::GenerateVehicleRepairPlanOutcomeCallable ObjectdetClient::generateVehicleRepairPlanCallable(const GenerateVehicleRepairPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateVehicleRepairPlanOutcome()>>(
[this, request]()
{
return this->generateVehicleRepairPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::GetAsyncJobResultOutcome ObjectdetClient::getAsyncJobResult(const GetAsyncJobResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,42 +519,6 @@ ObjectdetClient::GetAsyncJobResultOutcomeCallable ObjectdetClient::getAsyncJobRe
return task->get_future();
}
ObjectdetClient::GetVehicleRepairPlanOutcome ObjectdetClient::getVehicleRepairPlan(const GetVehicleRepairPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVehicleRepairPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVehicleRepairPlanOutcome(GetVehicleRepairPlanResult(outcome.result()));
else
return GetVehicleRepairPlanOutcome(outcome.error());
}
void ObjectdetClient::getVehicleRepairPlanAsync(const GetVehicleRepairPlanRequest& request, const GetVehicleRepairPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVehicleRepairPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
ObjectdetClient::GetVehicleRepairPlanOutcomeCallable ObjectdetClient::getVehicleRepairPlanCallable(const GetVehicleRepairPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVehicleRepairPlanOutcome()>>(
[this, request]()
{
return this->getVehicleRepairPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ObjectdetClient::RecognizeVehicleDamageOutcome ObjectdetClient::recognizeVehicleDamage(const RecognizeVehicleDamageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

82
objectdet/src/model/ClassifyVehicleInsuranceRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h>
using AlibabaCloud::Objectdet::Model::ClassifyVehicleInsuranceRequest;
ClassifyVehicleInsuranceRequest::ClassifyVehicleInsuranceRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "ClassifyVehicleInsurance")
{
setMethod(HttpRequest::Method::Post);
}
ClassifyVehicleInsuranceRequest::~ClassifyVehicleInsuranceRequest()
{}
bool ClassifyVehicleInsuranceRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/ClassifyVehicleInsuranceRequest.h>
using AlibabaCloud::Objectdet::Model::ClassifyVehicleInsuranceRequest;
ClassifyVehicleInsuranceRequest::ClassifyVehicleInsuranceRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "ClassifyVehicleInsurance") {
setMethod(HttpRequest::Method::Post);
}
void ClassifyVehicleInsuranceRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
ClassifyVehicleInsuranceRequest::~ClassifyVehicleInsuranceRequest() {}
bool ClassifyVehicleInsuranceRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string ClassifyVehicleInsuranceRequest::getOssFile()const
{
return ossFile_;
void ClassifyVehicleInsuranceRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void ClassifyVehicleInsuranceRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string ClassifyVehicleInsuranceRequest::getOssFile() const {
return ossFile_;
}
std::string ClassifyVehicleInsuranceRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void ClassifyVehicleInsuranceRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void ClassifyVehicleInsuranceRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string ClassifyVehicleInsuranceRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string ClassifyVehicleInsuranceRequest::getImageURL()const
{
return imageURL_;
void ClassifyVehicleInsuranceRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void ClassifyVehicleInsuranceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string ClassifyVehicleInsuranceRequest::getImageURL() const {
return imageURL_;
}
void ClassifyVehicleInsuranceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

82
objectdet/src/model/DetectIPCObjectRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/objectdet/model/DetectIPCObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectIPCObjectRequest;
DetectIPCObjectRequest::DetectIPCObjectRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectIPCObject")
{
setMethod(HttpRequest::Method::Post);
}
DetectIPCObjectRequest::~DetectIPCObjectRequest()
{}
bool DetectIPCObjectRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/DetectIPCObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectIPCObjectRequest;
DetectIPCObjectRequest::DetectIPCObjectRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectIPCObject") {
setMethod(HttpRequest::Method::Post);
}
void DetectIPCObjectRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectIPCObjectRequest::~DetectIPCObjectRequest() {}
bool DetectIPCObjectRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string DetectIPCObjectRequest::getOssFile()const
{
return ossFile_;
void DetectIPCObjectRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectIPCObjectRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectIPCObjectRequest::getOssFile() const {
return ossFile_;
}
std::string DetectIPCObjectRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectIPCObjectRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectIPCObjectRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectIPCObjectRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string DetectIPCObjectRequest::getImageURL()const
{
return imageURL_;
void DetectIPCObjectRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectIPCObjectRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string DetectIPCObjectRequest::getImageURL() const {
return imageURL_;
}
void DetectIPCObjectRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

94
objectdet/src/model/DetectKitchenAnimalsRequest.cc
View File

@@ -1,84 +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.
*/
#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_;
*/
#include <alibabacloud/objectdet/model/DetectKitchenAnimalsRequest.h>
using AlibabaCloud::Objectdet::Model::DetectKitchenAnimalsRequest;
DetectKitchenAnimalsRequest::DetectKitchenAnimalsRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectKitchenAnimals") {
setMethod(HttpRequest::Method::Post);
}
void DetectKitchenAnimalsRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectKitchenAnimalsRequest::~DetectKitchenAnimalsRequest() {}
bool DetectKitchenAnimalsRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string DetectKitchenAnimalsRequest::getImageURLB()const
{
return imageURLB_;
void DetectKitchenAnimalsRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectKitchenAnimalsRequest::setImageURLB(const std::string& imageURLB)
{
imageURLB_ = imageURLB;
setBodyParameter("ImageURLB", imageURLB);
std::string DetectKitchenAnimalsRequest::getImageURLB() const {
return imageURLB_;
}
std::string DetectKitchenAnimalsRequest::getImageURLA()const
{
return imageURLA_;
void DetectKitchenAnimalsRequest::setImageURLB(const std::string &imageURLB) {
imageURLB_ = imageURLB;
setBodyParameter(std::string("ImageURLB"), imageURLB);
}
void DetectKitchenAnimalsRequest::setImageURLA(const std::string& imageURLA)
{
imageURLA_ = imageURLA;
setBodyParameter("ImageURLA", imageURLA);
std::string DetectKitchenAnimalsRequest::getImageURLA() const {
return imageURLA_;
}
std::string DetectKitchenAnimalsRequest::getOssFile()const
{
return ossFile_;
void DetectKitchenAnimalsRequest::setImageURLA(const std::string &imageURLA) {
imageURLA_ = imageURLA;
setBodyParameter(std::string("ImageURLA"), imageURLA);
}
void DetectKitchenAnimalsRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectKitchenAnimalsRequest::getOssFile() const {
return ossFile_;
}
std::string DetectKitchenAnimalsRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectKitchenAnimalsRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectKitchenAnimalsRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectKitchenAnimalsRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DetectKitchenAnimalsRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}

73
objectdet/src/model/DetectMainBodyRequest.cc
View File

@@ -1,40 +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.
*/
#include <alibabacloud/objectdet/model/DetectMainBodyRequest.h>
using AlibabaCloud::Objectdet::Model::DetectMainBodyRequest;
DetectMainBodyRequest::DetectMainBodyRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectMainBody")
{
setMethod(HttpRequest::Method::Post);
}
DetectMainBodyRequest::~DetectMainBodyRequest()
{}
std::string DetectMainBodyRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/objectdet/model/DetectMainBodyRequest.h>
using AlibabaCloud::Objectdet::Model::DetectMainBodyRequest;
DetectMainBodyRequest::DetectMainBodyRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectMainBody") {
setMethod(HttpRequest::Method::Post);
}
void DetectMainBodyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
DetectMainBodyRequest::~DetectMainBodyRequest() {}
bool DetectMainBodyRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void DetectMainBodyRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string DetectMainBodyRequest::getOssFile() const {
return ossFile_;
}
void DetectMainBodyRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string DetectMainBodyRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DetectMainBodyRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string DetectMainBodyRequest::getImageURL() const {
return imageURL_;
}
void DetectMainBodyRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

8
objectdet/src/model/DetectMainBodyResult.cc
View File

@@ -41,14 +41,14 @@ void DetectMainBodyResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto locationNode = dataNode["Location"];
if(!locationNode["X"].isNull())
data_.location.x = std::stoi(locationNode["X"].asString());
if(!locationNode["Y"].isNull())
data_.location.y = std::stoi(locationNode["Y"].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());
if(!locationNode["Y"].isNull())
data_.location.y = std::stoi(locationNode["Y"].asString());
if(!locationNode["X"].isNull())
data_.location.x = std::stoi(locationNode["X"].asString());
}

73
objectdet/src/model/DetectObjectRequest.cc
View File

@@ -1,40 +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.
*/
#include <alibabacloud/objectdet/model/DetectObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectObjectRequest;
DetectObjectRequest::DetectObjectRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectObject")
{
setMethod(HttpRequest::Method::Post);
}
DetectObjectRequest::~DetectObjectRequest()
{}
std::string DetectObjectRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/objectdet/model/DetectObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectObjectRequest;
DetectObjectRequest::DetectObjectRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectObject") {
setMethod(HttpRequest::Method::Post);
}
void DetectObjectRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
DetectObjectRequest::~DetectObjectRequest() {}
bool DetectObjectRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void DetectObjectRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string DetectObjectRequest::getOssFile() const {
return ossFile_;
}
void DetectObjectRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string DetectObjectRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DetectObjectRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string DetectObjectRequest::getImageURL() const {
return imageURL_;
}
void DetectObjectRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

73
objectdet/src/model/DetectTransparentImageRequest.cc
View File

@@ -1,40 +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.
*/
#include <alibabacloud/objectdet/model/DetectTransparentImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectTransparentImageRequest;
DetectTransparentImageRequest::DetectTransparentImageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectTransparentImage")
{
setMethod(HttpRequest::Method::Post);
}
DetectTransparentImageRequest::~DetectTransparentImageRequest()
{}
std::string DetectTransparentImageRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/objectdet/model/DetectTransparentImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectTransparentImageRequest;
DetectTransparentImageRequest::DetectTransparentImageRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectTransparentImage") {
setMethod(HttpRequest::Method::Post);
}
void DetectTransparentImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
DetectTransparentImageRequest::~DetectTransparentImageRequest() {}
bool DetectTransparentImageRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void DetectTransparentImageRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string DetectTransparentImageRequest::getOssFile() const {
return ossFile_;
}
void DetectTransparentImageRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string DetectTransparentImageRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DetectTransparentImageRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string DetectTransparentImageRequest::getImageURL() const {
return imageURL_;
}
void DetectTransparentImageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

139
objectdet/src/model/DetectVehicleICongestionRequest.cc
View File

@@ -1,117 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleICongestionRequest;
DetectVehicleICongestionRequest::DetectVehicleICongestionRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicleICongestion")
{
setMethod(HttpRequest::Method::Post);
}
DetectVehicleICongestionRequest::~DetectVehicleICongestionRequest()
{}
bool DetectVehicleICongestionRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/DetectVehicleICongestionRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleICongestionRequest;
DetectVehicleICongestionRequest::DetectVehicleICongestionRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicleICongestion") {
setMethod(HttpRequest::Method::Post);
}
void DetectVehicleICongestionRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectVehicleICongestionRequest::~DetectVehicleICongestionRequest() {}
bool DetectVehicleICongestionRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
Array DetectVehicleICongestionRequest::getRoadRegions()const
{
return roadRegions_;
void DetectVehicleICongestionRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectVehicleICongestionRequest::setRoadRegions(const Array& roadRegions)
{
roadRegions_ = roadRegions;
setBodyParameter("RoadRegions", std::to_string(roadRegions));
std::vector<DetectVehicleICongestionRequest::RoadRegions> DetectVehicleICongestionRequest::getRoadRegions() const {
return roadRegions_;
}
std::string DetectVehicleICongestionRequest::getOriginRequestId()const
{
return originRequestId_;
void DetectVehicleICongestionRequest::setRoadRegions(const std::vector<DetectVehicleICongestionRequest::RoadRegions> &roadRegions) {
roadRegions_ = roadRegions;
for(int dep1 = 0; dep1 != roadRegions.size(); dep1++) {
for(int dep2 = 0; dep2 != roadRegions[dep1].roadRegion.size(); dep2++) {
setBodyParameter(std::string("RoadRegions") + "." + std::to_string(dep1 + 1) + ".RoadRegion." + std::to_string(dep2 + 1) + ".Point.X", std::to_string(roadRegions[dep1].roadRegion[dep2].point.x));
setBodyParameter(std::string("RoadRegions") + "." + std::to_string(dep1 + 1) + ".RoadRegion." + std::to_string(dep2 + 1) + ".Point.Y", std::to_string(roadRegions[dep1].roadRegion[dep2].point.y));
}
}
}
void DetectVehicleICongestionRequest::setOriginRequestId(const std::string& originRequestId)
{
originRequestId_ = originRequestId;
setParameter("OriginRequestId", originRequestId);
std::string DetectVehicleICongestionRequest::getOriginRequestId() const {
return originRequestId_;
}
std::string DetectVehicleICongestionRequest::getOssFile()const
{
return ossFile_;
void DetectVehicleICongestionRequest::setOriginRequestId(const std::string &originRequestId) {
originRequestId_ = originRequestId;
setParameter(std::string("OriginRequestId"), originRequestId);
}
void DetectVehicleICongestionRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectVehicleICongestionRequest::getOssFile() const {
return ossFile_;
}
Array DetectVehicleICongestionRequest::getPreRegionIntersectFeatures()const
{
return preRegionIntersectFeatures_;
void DetectVehicleICongestionRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectVehicleICongestionRequest::setPreRegionIntersectFeatures(const Array& preRegionIntersectFeatures)
{
preRegionIntersectFeatures_ = preRegionIntersectFeatures;
setBodyParameter("PreRegionIntersectFeatures", std::to_string(preRegionIntersectFeatures));
std::vector<DetectVehicleICongestionRequest::PreRegionIntersectFeatures> DetectVehicleICongestionRequest::getPreRegionIntersectFeatures() const {
return preRegionIntersectFeatures_;
}
std::string DetectVehicleICongestionRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectVehicleICongestionRequest::setPreRegionIntersectFeatures(const std::vector<DetectVehicleICongestionRequest::PreRegionIntersectFeatures> &preRegionIntersectFeatures) {
preRegionIntersectFeatures_ = preRegionIntersectFeatures;
for(int dep1 = 0; dep1 != preRegionIntersectFeatures.size(); dep1++) {
for(int dep2 = 0; dep2 != preRegionIntersectFeatures[dep1].features.size(); dep2++) {
setBodyParameter(std::string("PreRegionIntersectFeatures") + "." + std::to_string(dep1 + 1) + ".Features." + std::to_string(dep2 + 1), preRegionIntersectFeatures[dep1].features[dep2]);
}
}
}
void DetectVehicleICongestionRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectVehicleICongestionRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string DetectVehicleICongestionRequest::getStreamArn()const
{
return streamArn_;
void DetectVehicleICongestionRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectVehicleICongestionRequest::setStreamArn(const std::string& streamArn)
{
streamArn_ = streamArn;
setParameter("StreamArn", streamArn);
std::string DetectVehicleICongestionRequest::getStreamArn() const {
return streamArn_;
}
std::string DetectVehicleICongestionRequest::getImageURL()const
{
return imageURL_;
void DetectVehicleICongestionRequest::setStreamArn(const std::string &streamArn) {
streamArn_ = streamArn;
setParameter(std::string("StreamArn"), streamArn);
}
void DetectVehicleICongestionRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string DetectVehicleICongestionRequest::getImageURL() const {
return imageURL_;
}
void DetectVehicleICongestionRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

123
objectdet/src/model/DetectVehicleIllegalParkingRequest.cc
View File

@@ -1,106 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleIllegalParkingRequest;
DetectVehicleIllegalParkingRequest::DetectVehicleIllegalParkingRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicleIllegalParking")
{
setMethod(HttpRequest::Method::Post);
}
DetectVehicleIllegalParkingRequest::~DetectVehicleIllegalParkingRequest()
{}
bool DetectVehicleIllegalParkingRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/DetectVehicleIllegalParkingRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleIllegalParkingRequest;
DetectVehicleIllegalParkingRequest::DetectVehicleIllegalParkingRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicleIllegalParking") {
setMethod(HttpRequest::Method::Post);
}
void DetectVehicleIllegalParkingRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectVehicleIllegalParkingRequest::~DetectVehicleIllegalParkingRequest() {}
bool DetectVehicleIllegalParkingRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
Array DetectVehicleIllegalParkingRequest::getRoadRegions()const
{
return roadRegions_;
void DetectVehicleIllegalParkingRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectVehicleIllegalParkingRequest::setRoadRegions(const Array& roadRegions)
{
roadRegions_ = roadRegions;
setBodyParameter("RoadRegions", std::to_string(roadRegions));
std::vector<DetectVehicleIllegalParkingRequest::RoadRegions> DetectVehicleIllegalParkingRequest::getRoadRegions() const {
return roadRegions_;
}
std::string DetectVehicleIllegalParkingRequest::getOriginRequestId()const
{
return originRequestId_;
void DetectVehicleIllegalParkingRequest::setRoadRegions(const std::vector<DetectVehicleIllegalParkingRequest::RoadRegions> &roadRegions) {
roadRegions_ = roadRegions;
for(int dep1 = 0; dep1 != roadRegions.size(); dep1++) {
for(int dep2 = 0; dep2 != roadRegions[dep1].roadRegion.size(); dep2++) {
setBodyParameter(std::string("RoadRegions") + "." + std::to_string(dep1 + 1) + ".RoadRegion." + std::to_string(dep2 + 1) + ".Point.X", std::to_string(roadRegions[dep1].roadRegion[dep2].point.x));
setBodyParameter(std::string("RoadRegions") + "." + std::to_string(dep1 + 1) + ".RoadRegion." + std::to_string(dep2 + 1) + ".Point.Y", std::to_string(roadRegions[dep1].roadRegion[dep2].point.y));
}
}
}
void DetectVehicleIllegalParkingRequest::setOriginRequestId(const std::string& originRequestId)
{
originRequestId_ = originRequestId;
setParameter("OriginRequestId", originRequestId);
std::string DetectVehicleIllegalParkingRequest::getOriginRequestId() const {
return originRequestId_;
}
std::string DetectVehicleIllegalParkingRequest::getOssFile()const
{
return ossFile_;
void DetectVehicleIllegalParkingRequest::setOriginRequestId(const std::string &originRequestId) {
originRequestId_ = originRequestId;
setParameter(std::string("OriginRequestId"), originRequestId);
}
void DetectVehicleIllegalParkingRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectVehicleIllegalParkingRequest::getOssFile() const {
return ossFile_;
}
std::string DetectVehicleIllegalParkingRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectVehicleIllegalParkingRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectVehicleIllegalParkingRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectVehicleIllegalParkingRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string DetectVehicleIllegalParkingRequest::getStreamArn()const
{
return streamArn_;
void DetectVehicleIllegalParkingRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectVehicleIllegalParkingRequest::setStreamArn(const std::string& streamArn)
{
streamArn_ = streamArn;
setParameter("StreamArn", streamArn);
std::string DetectVehicleIllegalParkingRequest::getStreamArn() const {
return streamArn_;
}
std::string DetectVehicleIllegalParkingRequest::getImageURL()const
{
return imageURL_;
void DetectVehicleIllegalParkingRequest::setStreamArn(const std::string &streamArn) {
streamArn_ = streamArn;
setParameter(std::string("StreamArn"), streamArn);
}
void DetectVehicleIllegalParkingRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string DetectVehicleIllegalParkingRequest::getImageURL() const {
return imageURL_;
}
void DetectVehicleIllegalParkingRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

94
objectdet/src/model/DetectVehicleRequest.cc
View File

@@ -1,84 +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.
*/
#include <alibabacloud/objectdet/model/DetectVehicleRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleRequest;
DetectVehicleRequest::DetectVehicleRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicle")
{
setMethod(HttpRequest::Method::Post);
}
DetectVehicleRequest::~DetectVehicleRequest()
{}
bool DetectVehicleRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/DetectVehicleRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVehicleRequest;
DetectVehicleRequest::DetectVehicleRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectVehicle") {
setMethod(HttpRequest::Method::Post);
}
void DetectVehicleRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectVehicleRequest::~DetectVehicleRequest() {}
bool DetectVehicleRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string DetectVehicleRequest::getOssFile()const
{
return ossFile_;
void DetectVehicleRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectVehicleRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectVehicleRequest::getOssFile() const {
return ossFile_;
}
int DetectVehicleRequest::getImageType()const
{
return imageType_;
void DetectVehicleRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectVehicleRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
int DetectVehicleRequest::getImageType() const {
return imageType_;
}
std::string DetectVehicleRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectVehicleRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void DetectVehicleRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectVehicleRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string DetectVehicleRequest::getImageURL()const
{
return imageURL_;
void DetectVehicleRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectVehicleRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string DetectVehicleRequest::getImageURL() const {
return imageURL_;
}
void DetectVehicleRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

117
objectdet/src/model/DetectVideoFrameRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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));
}

66
objectdet/src/model/DetectVideoFrameResult.cc
View File

@@ -1,66 +0,0 @@
/*
* 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_;
}

118
objectdet/src/model/DetectVideoIPCObjectRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* 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/DetectVideoIPCObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVideoIPCObjectRequest;
DetectVideoIPCObjectRequest::DetectVideoIPCObjectRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectVideoIPCObject")
{
setMethod(HttpRequest::Method::Post);
}
DetectVideoIPCObjectRequest::~DetectVideoIPCObjectRequest()
{}
bool DetectVideoIPCObjectRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/DetectVideoIPCObjectRequest.h>
using AlibabaCloud::Objectdet::Model::DetectVideoIPCObjectRequest;
DetectVideoIPCObjectRequest::DetectVideoIPCObjectRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectVideoIPCObject") {
setMethod(HttpRequest::Method::Post);
}
void DetectVideoIPCObjectRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectVideoIPCObjectRequest::~DetectVideoIPCObjectRequest() {}
bool DetectVideoIPCObjectRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
long DetectVideoIPCObjectRequest::getStartTimestamp()const
{
return startTimestamp_;
void DetectVideoIPCObjectRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectVideoIPCObjectRequest::setStartTimestamp(long startTimestamp)
{
startTimestamp_ = startTimestamp;
setBodyParameter("StartTimestamp", std::to_string(startTimestamp));
long DetectVideoIPCObjectRequest::getStartTimestamp() const {
return startTimestamp_;
}
std::string DetectVideoIPCObjectRequest::getOssFile()const
{
return ossFile_;
void DetectVideoIPCObjectRequest::setStartTimestamp(long startTimestamp) {
startTimestamp_ = startTimestamp;
setBodyParameter(std::string("StartTimestamp"), std::to_string(startTimestamp));
}
void DetectVideoIPCObjectRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectVideoIPCObjectRequest::getOssFile() const {
return ossFile_;
}
bool DetectVideoIPCObjectRequest::getCallbackOnlyHasObject()const
{
return callbackOnlyHasObject_;
void DetectVideoIPCObjectRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectVideoIPCObjectRequest::setCallbackOnlyHasObject(bool callbackOnlyHasObject)
{
callbackOnlyHasObject_ = callbackOnlyHasObject;
setBodyParameter("CallbackOnlyHasObject", callbackOnlyHasObject ? "true" : "false");
bool DetectVideoIPCObjectRequest::getCallbackOnlyHasObject() const {
return callbackOnlyHasObject_;
}
std::string DetectVideoIPCObjectRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectVideoIPCObjectRequest::setCallbackOnlyHasObject(bool callbackOnlyHasObject) {
callbackOnlyHasObject_ = callbackOnlyHasObject;
setBodyParameter(std::string("CallbackOnlyHasObject"), callbackOnlyHasObject ? "true" : "false");
}
void DetectVideoIPCObjectRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectVideoIPCObjectRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
bool DetectVideoIPCObjectRequest::getAsync()const
{
return async_;
void DetectVideoIPCObjectRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectVideoIPCObjectRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool DetectVideoIPCObjectRequest::getAsync() const {
return async_;
}
std::string DetectVideoIPCObjectRequest::getVideoURL()const
{
return videoURL_;
void DetectVideoIPCObjectRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void DetectVideoIPCObjectRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string DetectVideoIPCObjectRequest::getVideoURL() const {
return videoURL_;
}
void DetectVideoIPCObjectRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

73
objectdet/src/model/DetectWhiteBaseImageRequest.cc
View File

@@ -1,40 +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.
*/
#include <alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectWhiteBaseImageRequest;
DetectWhiteBaseImageRequest::DetectWhiteBaseImageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "DetectWhiteBaseImage")
{
setMethod(HttpRequest::Method::Post);
}
DetectWhiteBaseImageRequest::~DetectWhiteBaseImageRequest()
{}
std::string DetectWhiteBaseImageRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/objectdet/model/DetectWhiteBaseImageRequest.h>
using AlibabaCloud::Objectdet::Model::DetectWhiteBaseImageRequest;
DetectWhiteBaseImageRequest::DetectWhiteBaseImageRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectWhiteBaseImage") {
setMethod(HttpRequest::Method::Post);
}
void DetectWhiteBaseImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
DetectWhiteBaseImageRequest::~DetectWhiteBaseImageRequest() {}
bool DetectWhiteBaseImageRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
void DetectWhiteBaseImageRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
std::string DetectWhiteBaseImageRequest::getOssFile() const {
return ossFile_;
}
void DetectWhiteBaseImageRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string DetectWhiteBaseImageRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void DetectWhiteBaseImageRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string DetectWhiteBaseImageRequest::getImageURL() const {
return imageURL_;
}
void DetectWhiteBaseImageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

108
objectdet/src/model/DetectWorkwearRequest.cc
View File

@@ -1,97 +1,81 @@
/*
* 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_;
*/
#include <alibabacloud/objectdet/model/DetectWorkwearRequest.h>
using AlibabaCloud::Objectdet::Model::DetectWorkwearRequest;
DetectWorkwearRequest::DetectWorkwearRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "DetectWorkwear") {
setMethod(HttpRequest::Method::Post);
}
void DetectWorkwearRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
DetectWorkwearRequest::~DetectWorkwearRequest() {}
bool DetectWorkwearRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string DetectWorkwearRequest::getOssFile()const
{
return ossFile_;
void DetectWorkwearRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void DetectWorkwearRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string DetectWorkwearRequest::getOssFile() const {
return ossFile_;
}
std::string DetectWorkwearRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void DetectWorkwearRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void DetectWorkwearRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string DetectWorkwearRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
Struct DetectWorkwearRequest::getClothes()const
{
return clothes_;
void DetectWorkwearRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void DetectWorkwearRequest::setClothes(const Struct& clothes)
{
clothes_ = clothes;
setBodyParameter("Clothes", std::to_string(clothes));
DetectWorkwearRequest::Clothes DetectWorkwearRequest::getClothes() const {
return clothes_;
}
std::vector<std::string> DetectWorkwearRequest::getLabels()const
{
return labels_;
void DetectWorkwearRequest::setClothes(const DetectWorkwearRequest::Clothes &clothes) {
clothes_ = clothes;
setBodyParameter(std::string("Clothes") + ".Threshold", std::to_string(clothes.threshold));
setBodyParameter(std::string("Clothes") + ".MaxNum", std::to_string(clothes.maxNum));
}
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::vector<std::string> DetectWorkwearRequest::getLabels() const {
return labels_;
}
std::string DetectWorkwearRequest::getImageUrl()const
{
return imageUrl_;
void DetectWorkwearRequest::setLabels(const std::vector<std::string> &labels) {
labels_ = labels;
}
void DetectWorkwearRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
std::string DetectWorkwearRequest::getImageUrl() const {
return imageUrl_;
}
void DetectWorkwearRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
}

45
objectdet/src/model/GenerateVehicleRepairPlanRequest.cc
View File

@@ -1,45 +0,0 @@
/*
* 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/GenerateVehicleRepairPlanRequest.h>
using AlibabaCloud::Objectdet::Model::GenerateVehicleRepairPlanRequest;
GenerateVehicleRepairPlanRequest::GenerateVehicleRepairPlanRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "GenerateVehicleRepairPlan")
{
setMethod(HttpRequest::Method::Post);
}
GenerateVehicleRepairPlanRequest::~GenerateVehicleRepairPlanRequest()
{}
std::vector<GenerateVehicleRepairPlanRequest::DamageImageList> GenerateVehicleRepairPlanRequest::getDamageImageList()const
{
return damageImageList_;
}
void GenerateVehicleRepairPlanRequest::setDamageImageList(const std::vector<DamageImageList>& damageImageList)
{
damageImageList_ = damageImageList;
for(int dep1 = 0; dep1!= damageImageList.size(); dep1++) {
auto damageImageListObj = damageImageList.at(dep1);
std::string damageImageListObjStr = "DamageImageList." + std::to_string(dep1 + 1);
setParameter(damageImageListObjStr + ".ImageUrl", damageImageListObj.imageUrl);
setParameter(damageImageListObjStr + ".CreateTimeStamp", damageImageListObj.createTimeStamp);
}
}

80
objectdet/src/model/GenerateVehicleRepairPlanResult.cc
View File

@@ -1,80 +0,0 @@
/*
* 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/GenerateVehicleRepairPlanResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
GenerateVehicleRepairPlanResult::GenerateVehicleRepairPlanResult() :
ServiceResult()
{}
GenerateVehicleRepairPlanResult::GenerateVehicleRepairPlanResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenerateVehicleRepairPlanResult::~GenerateVehicleRepairPlanResult()
{}
void GenerateVehicleRepairPlanResult::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["TaskId"].isNull())
data_.taskId = dataNode["TaskId"].asString();
if(!value["HttpCode"].isNull())
httpCode_ = std::stoi(value["HttpCode"].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";
}
int GenerateVehicleRepairPlanResult::getHttpCode()const
{
return httpCode_;
}
GenerateVehicleRepairPlanResult::Data GenerateVehicleRepairPlanResult::getData()const
{
return data_;
}
std::string GenerateVehicleRepairPlanResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GenerateVehicleRepairPlanResult::getCode()const
{
return code_;
}
bool GenerateVehicleRepairPlanResult::getSuccess()const
{
return success_;
}

94
objectdet/src/model/GetAsyncJobResultRequest.cc
View File

@@ -1,84 +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.
*/
#include <alibabacloud/objectdet/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Objectdet::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "GetAsyncJobResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
{}
bool GetAsyncJobResultRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Objectdet::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "GetAsyncJobResult") {
setMethod(HttpRequest::Method::Post);
}
void GetAsyncJobResultRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
bool GetAsyncJobResultRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
void GetAsyncJobResultRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
std::string GetAsyncJobResultRequest::getJobId() const {
return jobId_;
}
std::string GetAsyncJobResultRequest::getOssFile()const
{
return ossFile_;
void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setBodyParameter(std::string("JobId"), jobId);
}
void GetAsyncJobResultRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string GetAsyncJobResultRequest::getOssFile() const {
return ossFile_;
}
std::string GetAsyncJobResultRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void GetAsyncJobResultRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void GetAsyncJobResultRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string GetAsyncJobResultRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
void GetAsyncJobResultRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool GetAsyncJobResultRequest::getAsync() const {
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}

95
objectdet/src/model/GetVehicleRepairPlanRequest.cc
View File

@@ -1,95 +0,0 @@
/*
* 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/GetVehicleRepairPlanRequest.h>
using AlibabaCloud::Objectdet::Model::GetVehicleRepairPlanRequest;
GetVehicleRepairPlanRequest::GetVehicleRepairPlanRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "GetVehicleRepairPlan")
{
setMethod(HttpRequest::Method::Post);
}
GetVehicleRepairPlanRequest::~GetVehicleRepairPlanRequest()
{}
std::string GetVehicleRepairPlanRequest::getVinCodeImage()const
{
return vinCodeImage_;
}
void GetVehicleRepairPlanRequest::setVinCodeImage(const std::string& vinCodeImage)
{
vinCodeImage_ = vinCodeImage;
setBodyParameter("VinCodeImage", vinCodeImage);
}
bool GetVehicleRepairPlanRequest::getFormatResultToJson()const
{
return formatResultToJson_;
}
void GetVehicleRepairPlanRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
}
std::string GetVehicleRepairPlanRequest::getCarNumberImage()const
{
return carNumberImage_;
}
void GetVehicleRepairPlanRequest::setCarNumberImage(const std::string& carNumberImage)
{
carNumberImage_ = carNumberImage;
setBodyParameter("CarNumberImage", carNumberImage);
}
std::string GetVehicleRepairPlanRequest::getTaskId()const
{
return taskId_;
}
void GetVehicleRepairPlanRequest::setTaskId(const std::string& taskId)
{
taskId_ = taskId;
setBodyParameter("TaskId", taskId);
}
std::string GetVehicleRepairPlanRequest::getOssFile()const
{
return ossFile_;
}
void GetVehicleRepairPlanRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
}
std::string GetVehicleRepairPlanRequest::getRequestProxyBy()const
{
return requestProxyBy_;
}
void GetVehicleRepairPlanRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
}

108
objectdet/src/model/GetVehicleRepairPlanResult.cc
View File

@@ -1,108 +0,0 @@
/*
* 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/GetVehicleRepairPlanResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Objectdet;
using namespace AlibabaCloud::Objectdet::Model;
GetVehicleRepairPlanResult::GetVehicleRepairPlanResult() :
ServiceResult()
{}
GetVehicleRepairPlanResult::GetVehicleRepairPlanResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVehicleRepairPlanResult::~GetVehicleRepairPlanResult()
{}
void GetVehicleRepairPlanResult::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["FrameNo"].isNull())
data_.frameNo = dataNode["FrameNo"].asString();
auto allRepairPartsNode = dataNode["RepairParts"]["RepairItems"];
for (auto dataNodeRepairPartsRepairItems : allRepairPartsNode)
{
Data::RepairItems repairItemsObject;
if(!dataNodeRepairPartsRepairItems["RelationType"].isNull())
repairItemsObject.relationType = dataNodeRepairPartsRepairItems["RelationType"].asString();
if(!dataNodeRepairPartsRepairItems["PartsStdCode"].isNull())
repairItemsObject.partsStdCode = dataNodeRepairPartsRepairItems["PartsStdCode"].asString();
if(!dataNodeRepairPartsRepairItems["PartNameMatch"].isNull())
repairItemsObject.partNameMatch = dataNodeRepairPartsRepairItems["PartNameMatch"].asString() == "true";
if(!dataNodeRepairPartsRepairItems["RepairFee"].isNull())
repairItemsObject.repairFee = dataNodeRepairPartsRepairItems["RepairFee"].asString();
if(!dataNodeRepairPartsRepairItems["OutStandardPartsName"].isNull())
repairItemsObject.outStandardPartsName = dataNodeRepairPartsRepairItems["OutStandardPartsName"].asString();
if(!dataNodeRepairPartsRepairItems["PartsStdName"].isNull())
repairItemsObject.partsStdName = dataNodeRepairPartsRepairItems["PartsStdName"].asString();
if(!dataNodeRepairPartsRepairItems["RepairTypeName"].isNull())
repairItemsObject.repairTypeName = dataNodeRepairPartsRepairItems["RepairTypeName"].asString();
if(!dataNodeRepairPartsRepairItems["RepairType"].isNull())
repairItemsObject.repairType = dataNodeRepairPartsRepairItems["RepairType"].asString();
if(!dataNodeRepairPartsRepairItems["OeMatch"].isNull())
repairItemsObject.oeMatch = dataNodeRepairPartsRepairItems["OeMatch"].asString() == "true";
if(!dataNodeRepairPartsRepairItems["OutStandardPartsId"].isNull())
repairItemsObject.outStandardPartsId = dataNodeRepairPartsRepairItems["OutStandardPartsId"].asString();
if(!dataNodeRepairPartsRepairItems["GarageType"].isNull())
repairItemsObject.garageType = dataNodeRepairPartsRepairItems["GarageType"].asString();
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["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
int GetVehicleRepairPlanResult::getHttpCode()const
{
return httpCode_;
}
GetVehicleRepairPlanResult::Data GetVehicleRepairPlanResult::getData()const
{
return data_;
}
std::string GetVehicleRepairPlanResult::getErrorMessage()const
{
return errorMessage_;
}
std::string GetVehicleRepairPlanResult::getCode()const
{
return code_;
}
bool GetVehicleRepairPlanResult::getSuccess()const
{
return success_;
}

82
objectdet/src/model/RecognizeVehicleDamageRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDamageRequest;
RecognizeVehicleDamageRequest::RecognizeVehicleDamageRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDamage")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehicleDamageRequest::~RecognizeVehicleDamageRequest()
{}
bool RecognizeVehicleDamageRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDamageRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDamageRequest;
RecognizeVehicleDamageRequest::RecognizeVehicleDamageRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDamage") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVehicleDamageRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeVehicleDamageRequest::~RecognizeVehicleDamageRequest() {}
bool RecognizeVehicleDamageRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string RecognizeVehicleDamageRequest::getOssFile()const
{
return ossFile_;
void RecognizeVehicleDamageRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void RecognizeVehicleDamageRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string RecognizeVehicleDamageRequest::getOssFile() const {
return ossFile_;
}
std::string RecognizeVehicleDamageRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void RecognizeVehicleDamageRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void RecognizeVehicleDamageRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string RecognizeVehicleDamageRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string RecognizeVehicleDamageRequest::getImageURL()const
{
return imageURL_;
void RecognizeVehicleDamageRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void RecognizeVehicleDamageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeVehicleDamageRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVehicleDamageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

82
objectdet/src/model/RecognizeVehicleDashboardRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDashboardRequest;
RecognizeVehicleDashboardRequest::RecognizeVehicleDashboardRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDashboard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehicleDashboardRequest::~RecognizeVehicleDashboardRequest()
{}
bool RecognizeVehicleDashboardRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/RecognizeVehicleDashboardRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehicleDashboardRequest;
RecognizeVehicleDashboardRequest::RecognizeVehicleDashboardRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleDashboard") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVehicleDashboardRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeVehicleDashboardRequest::~RecognizeVehicleDashboardRequest() {}
bool RecognizeVehicleDashboardRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string RecognizeVehicleDashboardRequest::getOssFile()const
{
return ossFile_;
void RecognizeVehicleDashboardRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void RecognizeVehicleDashboardRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string RecognizeVehicleDashboardRequest::getOssFile() const {
return ossFile_;
}
std::string RecognizeVehicleDashboardRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void RecognizeVehicleDashboardRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void RecognizeVehicleDashboardRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string RecognizeVehicleDashboardRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string RecognizeVehicleDashboardRequest::getImageURL()const
{
return imageURL_;
void RecognizeVehicleDashboardRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void RecognizeVehicleDashboardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeVehicleDashboardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVehicleDashboardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

82
objectdet/src/model/RecognizeVehiclePartsRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehiclePartsRequest;
RecognizeVehiclePartsRequest::RecognizeVehiclePartsRequest() :
RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleParts")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVehiclePartsRequest::~RecognizeVehiclePartsRequest()
{}
bool RecognizeVehiclePartsRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/objectdet/model/RecognizeVehiclePartsRequest.h>
using AlibabaCloud::Objectdet::Model::RecognizeVehiclePartsRequest;
RecognizeVehiclePartsRequest::RecognizeVehiclePartsRequest()
: RpcServiceRequest("objectdet", "2019-12-30", "RecognizeVehicleParts") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVehiclePartsRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeVehiclePartsRequest::~RecognizeVehiclePartsRequest() {}
bool RecognizeVehiclePartsRequest::getFormatResultToJson() const {
return formatResultToJson_;
}
std::string RecognizeVehiclePartsRequest::getOssFile()const
{
return ossFile_;
void RecognizeVehiclePartsRequest::setFormatResultToJson(bool formatResultToJson) {
formatResultToJson_ = formatResultToJson;
setParameter(std::string("FormatResultToJson"), formatResultToJson ? "true" : "false");
}
void RecognizeVehiclePartsRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
std::string RecognizeVehiclePartsRequest::getOssFile() const {
return ossFile_;
}
std::string RecognizeVehiclePartsRequest::getRequestProxyBy()const
{
return requestProxyBy_;
void RecognizeVehiclePartsRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void RecognizeVehiclePartsRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
std::string RecognizeVehiclePartsRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
std::string RecognizeVehiclePartsRequest::getImageURL()const
{
return imageURL_;
void RecognizeVehiclePartsRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
void RecognizeVehiclePartsRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeVehiclePartsRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVehiclePartsRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}