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

Update RefineMask.

Browse Source
This commit is contained in:
sdk-team
2022-09-29 09:02:55 +00:00
parent 8f129b76e0
commit 39f77beaaf
53 changed files with 1791 additions and 1505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1284
1.36.1285

80
imageseg/include/alibabacloud/imageseg/model/ChangeSkyRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT ChangeSkyRequest : public RpcServiceRequest
{
public:
ChangeSkyRequest();
~ChangeSkyRequest();
std::string getReplaceImageURL()const;
void setReplaceImageURL(const std::string& replaceImageURL);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string replaceImageURL_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT ChangeSkyRequest : public RpcServiceRequest {
public:
ChangeSkyRequest();
~ChangeSkyRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getReplaceImageURL() const;
void setReplaceImageURL(const std::string &replaceImageURL);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string replaceImageURL_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_CHANGESKYREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/GetAsyncJobResultRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
bool async_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
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:
std::string jobId_;
std::string ossFile_;
std::string requestProxyBy_;
bool async_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_GETASYNCJOBRESULTREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/ParseFaceRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT ParseFaceRequest : public RpcServiceRequest
{
public:
ParseFaceRequest();
~ParseFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT ParseFaceRequest : public RpcServiceRequest {
public:
ParseFaceRequest();
~ParseFaceRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_PARSEFACEREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/RefineMaskRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT RefineMaskRequest : public RpcServiceRequest
{
public:
RefineMaskRequest();
~RefineMaskRequest();
std::string getMaskImageURL()const;
void setMaskImageURL(const std::string& maskImageURL);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string maskImageURL_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT RefineMaskRequest : public RpcServiceRequest {
public:
RefineMaskRequest();
~RefineMaskRequest();
std::string getMaskImageURL() const;
void setMaskImageURL(const std::string &maskImageURL);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string maskImageURL_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_REFINEMASKREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentAnimalRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentAnimalRequest : public RpcServiceRequest
{
public:
SegmentAnimalRequest();
~SegmentAnimalRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentAnimalRequest : public RpcServiceRequest {
public:
SegmentAnimalRequest();
~SegmentAnimalRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTANIMALREQUEST_H_

86
imageseg/include/alibabacloud/imageseg/model/SegmentBodyRequest.h
View File

@@ -1,54 +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_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentBodyRequest : public RpcServiceRequest
{
public:
SegmentBodyRequest();
~SegmentBodyRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
bool getAsync()const;
void setAsync(bool async);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
bool async_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentBodyRequest : public RpcServiceRequest {
public:
SegmentBodyRequest();
~SegmentBodyRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
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);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
bool async_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTBODYREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentClothRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentClothRequest : public RpcServiceRequest
{
public:
SegmentClothRequest();
~SegmentClothRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentClothRequest : public RpcServiceRequest {
public:
SegmentClothRequest();
~SegmentClothRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCLOTHREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentCommodityRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommodityRequest : public RpcServiceRequest
{
public:
SegmentCommodityRequest();
~SegmentCommodityRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommodityRequest : public RpcServiceRequest {
public:
SegmentCommodityRequest();
~SegmentCommodityRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMODITYREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentCommonImageRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommonImageRequest : public RpcServiceRequest
{
public:
SegmentCommonImageRequest();
~SegmentCommonImageRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentCommonImageRequest : public RpcServiceRequest {
public:
SegmentCommonImageRequest();
~SegmentCommonImageRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTCOMMONIMAGEREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentFaceRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFaceRequest : public RpcServiceRequest
{
public:
SegmentFaceRequest();
~SegmentFaceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFaceRequest : public RpcServiceRequest {
public:
SegmentFaceRequest();
~SegmentFaceRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFACEREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentFoodRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFoodRequest : public RpcServiceRequest
{
public:
SegmentFoodRequest();
~SegmentFoodRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFoodRequest : public RpcServiceRequest {
public:
SegmentFoodRequest();
~SegmentFoodRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFOODREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentFurnitureRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFurnitureRequest : public RpcServiceRequest
{
public:
SegmentFurnitureRequest();
~SegmentFurnitureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentFurnitureRequest : public RpcServiceRequest {
public:
SegmentFurnitureRequest();
~SegmentFurnitureRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTFURNITUREREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentHDBodyRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDBodyRequest : public RpcServiceRequest
{
public:
SegmentHDBodyRequest();
~SegmentHDBodyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDBodyRequest : public RpcServiceRequest {
public:
SegmentHDBodyRequest();
~SegmentHDBodyRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDBODYREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentHDCommonImageRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDCommonImageRequest : public RpcServiceRequest
{
public:
SegmentHDCommonImageRequest();
~SegmentHDCommonImageRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getImageUrl()const;
void setImageUrl(const std::string& imageUrl);
private:
bool async_;
std::string imageUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDCommonImageRequest : public RpcServiceRequest {
public:
SegmentHDCommonImageRequest();
~SegmentHDCommonImageRequest();
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);
std::string getImageUrl() const;
void setImageUrl(const std::string &imageUrl);
private:
std::string ossFile_;
std::string requestProxyBy_;
bool async_;
std::string imageUrl_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDCOMMONIMAGEREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentHDSkyRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDSkyRequest : public RpcServiceRequest
{
public:
SegmentHDSkyRequest();
~SegmentHDSkyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHDSkyRequest : public RpcServiceRequest {
public:
SegmentHDSkyRequest();
~SegmentHDSkyRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHDSKYREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentHairRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHairRequest : public RpcServiceRequest
{
public:
SegmentHairRequest();
~SegmentHairRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHairRequest : public RpcServiceRequest {
public:
SegmentHairRequest();
~SegmentHairRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHAIRREQUEST_H_

80
imageseg/include/alibabacloud/imageseg/model/SegmentHeadRequest.h
View File

@@ -1,51 +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_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHeadRequest : public RpcServiceRequest
{
public:
SegmentHeadRequest();
~SegmentHeadRequest();
std::string getReturnForm()const;
void setReturnForm(const std::string& returnForm);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string returnForm_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentHeadRequest : public RpcServiceRequest {
public:
SegmentHeadRequest();
~SegmentHeadRequest();
std::string getReturnForm() const;
void setReturnForm(const std::string &returnForm);
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string returnForm_;
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTHEADREQUEST_H_

2
imageseg/include/alibabacloud/imageseg/model/SegmentHeadResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
struct Element
{
int x;
int y;
std::string imageURL;
int y;
int height;
int width;
};

74
imageseg/include/alibabacloud/imageseg/model/SegmentLogoRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentLogoRequest : public RpcServiceRequest
{
public:
SegmentLogoRequest();
~SegmentLogoRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentLogoRequest : public RpcServiceRequest {
public:
SegmentLogoRequest();
~SegmentLogoRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTLOGOREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentSceneRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSceneRequest : public RpcServiceRequest
{
public:
SegmentSceneRequest();
~SegmentSceneRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSceneRequest : public RpcServiceRequest {
public:
SegmentSceneRequest();
~SegmentSceneRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSCENEREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentSkinRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSkinRequest : public RpcServiceRequest
{
public:
SegmentSkinRequest();
~SegmentSkinRequest();
std::string getURL()const;
void setURL(const std::string& uRL);
private:
std::string uRL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSkinRequest : public RpcServiceRequest {
public:
SegmentSkinRequest();
~SegmentSkinRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getURL() const;
void setURL(const std::string &uRL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string uRL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKINREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentSkyRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSkyRequest : public RpcServiceRequest
{
public:
SegmentSkyRequest();
~SegmentSkyRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentSkyRequest : public RpcServiceRequest {
public:
SegmentSkyRequest();
~SegmentSkyRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTSKYREQUEST_H_

74
imageseg/include/alibabacloud/imageseg/model/SegmentVehicleRequest.h
View File

@@ -1,48 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageseg/ImagesegExport.h>
namespace AlibabaCloud
{
namespace Imageseg
{
namespace Model
{
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentVehicleRequest : public RpcServiceRequest
{
public:
SegmentVehicleRequest();
~SegmentVehicleRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#define ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_
#include <alibabacloud/imageseg/ImagesegExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageseg {
namespace Model {
class ALIBABACLOUD_IMAGESEG_EXPORT SegmentVehicleRequest : public RpcServiceRequest {
public:
SegmentVehicleRequest();
~SegmentVehicleRequest();
std::string getOssFile() const;
void setOssFile(const std::string &ossFile);
std::string getRequestProxyBy() const;
void setRequestProxyBy(const std::string &requestProxyBy);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string ossFile_;
std::string requestProxyBy_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageseg
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGESEG_MODEL_SEGMENTVEHICLEREQUEST_H_

6
imageseg/src/ImagesegClient.cc
View File

@@ -31,21 +31,21 @@ ImagesegClient::ImagesegClient(const Credentials &credentials, const ClientConfi
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ImagesegClient::ImagesegClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ImagesegClient::ImagesegClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageseg");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ImagesegClient::~ImagesegClient()

76
imageseg/src/model/ChangeSkyRequest.cc
View File

@@ -1,51 +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/imageseg/model/ChangeSkyRequest.h>
using AlibabaCloud::Imageseg::Model::ChangeSkyRequest;
ChangeSkyRequest::ChangeSkyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "ChangeSky")
{
setMethod(HttpRequest::Method::Post);
}
ChangeSkyRequest::~ChangeSkyRequest()
{}
std::string ChangeSkyRequest::getReplaceImageURL()const
{
return replaceImageURL_;
*/
#include <alibabacloud/imageseg/model/ChangeSkyRequest.h>
using AlibabaCloud::Imageseg::Model::ChangeSkyRequest;
ChangeSkyRequest::ChangeSkyRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "ChangeSky") {
setMethod(HttpRequest::Method::Post);
}
void ChangeSkyRequest::setReplaceImageURL(const std::string& replaceImageURL)
{
replaceImageURL_ = replaceImageURL;
setParameter("ReplaceImageURL", replaceImageURL);
ChangeSkyRequest::~ChangeSkyRequest() {}
std::string ChangeSkyRequest::getOssFile() const {
return ossFile_;
}
std::string ChangeSkyRequest::getImageURL()const
{
return imageURL_;
void ChangeSkyRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void ChangeSkyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string ChangeSkyRequest::getReplaceImageURL() const {
return replaceImageURL_;
}
void ChangeSkyRequest::setReplaceImageURL(const std::string &replaceImageURL) {
replaceImageURL_ = replaceImageURL;
setParameter(std::string("ReplaceImageURL"), replaceImageURL);
}
std::string ChangeSkyRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void ChangeSkyRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string ChangeSkyRequest::getImageURL() const {
return imageURL_;
}
void ChangeSkyRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

76
imageseg/src/model/GetAsyncJobResultRequest.cc
View File

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

16
imageseg/src/model/GetAsyncJobResultResult.cc
View File

@@ -40,16 +40,16 @@ void GetAsyncJobResultResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
}

64
imageseg/src/model/ParseFaceRequest.cc
View File

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

4
imageseg/src/model/ParseFaceResult.cc
View File

@@ -46,10 +46,10 @@ void ParseFaceResult::parse(const std::string &payload)
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Name"].isNull())
elementObject.name = dataNodeElementsElement["Name"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["Name"].isNull())
elementObject.name = dataNodeElementsElement["Name"].asString();
data_.elements.push_back(elementObject);
}

76
imageseg/src/model/RefineMaskRequest.cc
View File

@@ -1,51 +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/imageseg/model/RefineMaskRequest.h>
using AlibabaCloud::Imageseg::Model::RefineMaskRequest;
RefineMaskRequest::RefineMaskRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "RefineMask")
{
setMethod(HttpRequest::Method::Post);
}
RefineMaskRequest::~RefineMaskRequest()
{}
std::string RefineMaskRequest::getMaskImageURL()const
{
return maskImageURL_;
*/
#include <alibabacloud/imageseg/model/RefineMaskRequest.h>
using AlibabaCloud::Imageseg::Model::RefineMaskRequest;
RefineMaskRequest::RefineMaskRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "RefineMask") {
setMethod(HttpRequest::Method::Post);
}
void RefineMaskRequest::setMaskImageURL(const std::string& maskImageURL)
{
maskImageURL_ = maskImageURL;
setBodyParameter("MaskImageURL", maskImageURL);
RefineMaskRequest::~RefineMaskRequest() {}
std::string RefineMaskRequest::getMaskImageURL() const {
return maskImageURL_;
}
std::string RefineMaskRequest::getImageURL()const
{
return imageURL_;
void RefineMaskRequest::setMaskImageURL(const std::string &maskImageURL) {
maskImageURL_ = maskImageURL;
setBodyParameter(std::string("MaskImageURL"), maskImageURL);
}
void RefineMaskRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RefineMaskRequest::getOssFile() const {
return ossFile_;
}
void RefineMaskRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string RefineMaskRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void RefineMaskRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string RefineMaskRequest::getImageURL() const {
return imageURL_;
}
void RefineMaskRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

76
imageseg/src/model/SegmentAnimalRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentAnimalRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentAnimalRequest;
SegmentAnimalRequest::SegmentAnimalRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentAnimal")
{
setMethod(HttpRequest::Method::Post);
}
SegmentAnimalRequest::~SegmentAnimalRequest()
{}
std::string SegmentAnimalRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentAnimalRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentAnimalRequest;
SegmentAnimalRequest::SegmentAnimalRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentAnimal") {
setMethod(HttpRequest::Method::Post);
}
void SegmentAnimalRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentAnimalRequest::~SegmentAnimalRequest() {}
std::string SegmentAnimalRequest::getReturnForm() const {
return returnForm_;
}
std::string SegmentAnimalRequest::getImageURL()const
{
return imageURL_;
void SegmentAnimalRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentAnimalRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentAnimalRequest::getOssFile() const {
return ossFile_;
}
void SegmentAnimalRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentAnimalRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentAnimalRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentAnimalRequest::getImageURL() const {
return imageURL_;
}
void SegmentAnimalRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

88
imageseg/src/model/SegmentBodyRequest.cc
View File

@@ -1,62 +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/imageseg/model/SegmentBodyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentBodyRequest;
SegmentBodyRequest::SegmentBodyRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentBody")
{
setMethod(HttpRequest::Method::Post);
}
SegmentBodyRequest::~SegmentBodyRequest()
{}
std::string SegmentBodyRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentBodyRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentBodyRequest;
SegmentBodyRequest::SegmentBodyRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentBody") {
setMethod(HttpRequest::Method::Post);
}
void SegmentBodyRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentBodyRequest::~SegmentBodyRequest() {}
std::string SegmentBodyRequest::getReturnForm() const {
return returnForm_;
}
bool SegmentBodyRequest::getAsync()const
{
return async_;
void SegmentBodyRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentBodyRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
std::string SegmentBodyRequest::getOssFile() const {
return ossFile_;
}
std::string SegmentBodyRequest::getImageURL()const
{
return imageURL_;
void SegmentBodyRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void SegmentBodyRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentBodyRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentBodyRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
bool SegmentBodyRequest::getAsync() const {
return async_;
}
void SegmentBodyRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
std::string SegmentBodyRequest::getImageURL() const {
return imageURL_;
}
void SegmentBodyRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

64
imageseg/src/model/SegmentClothRequest.cc
View File

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

76
imageseg/src/model/SegmentCommodityRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentCommodityRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommodityRequest;
SegmentCommodityRequest::SegmentCommodityRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommodity")
{
setMethod(HttpRequest::Method::Post);
}
SegmentCommodityRequest::~SegmentCommodityRequest()
{}
std::string SegmentCommodityRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentCommodityRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommodityRequest;
SegmentCommodityRequest::SegmentCommodityRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommodity") {
setMethod(HttpRequest::Method::Post);
}
void SegmentCommodityRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentCommodityRequest::~SegmentCommodityRequest() {}
std::string SegmentCommodityRequest::getReturnForm() const {
return returnForm_;
}
std::string SegmentCommodityRequest::getImageURL()const
{
return imageURL_;
void SegmentCommodityRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentCommodityRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentCommodityRequest::getOssFile() const {
return ossFile_;
}
void SegmentCommodityRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentCommodityRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentCommodityRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentCommodityRequest::getImageURL() const {
return imageURL_;
}
void SegmentCommodityRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

76
imageseg/src/model/SegmentCommonImageRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommonImageRequest;
SegmentCommonImageRequest::SegmentCommonImageRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommonImage")
{
setMethod(HttpRequest::Method::Post);
}
SegmentCommonImageRequest::~SegmentCommonImageRequest()
{}
std::string SegmentCommonImageRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentCommonImageRequest;
SegmentCommonImageRequest::SegmentCommonImageRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentCommonImage") {
setMethod(HttpRequest::Method::Post);
}
void SegmentCommonImageRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentCommonImageRequest::~SegmentCommonImageRequest() {}
std::string SegmentCommonImageRequest::getReturnForm() const {
return returnForm_;
}
std::string SegmentCommonImageRequest::getImageURL()const
{
return imageURL_;
void SegmentCommonImageRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentCommonImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentCommonImageRequest::getOssFile() const {
return ossFile_;
}
void SegmentCommonImageRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentCommonImageRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentCommonImageRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentCommonImageRequest::getImageURL() const {
return imageURL_;
}
void SegmentCommonImageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

64
imageseg/src/model/SegmentFaceRequest.cc
View File

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

8
imageseg/src/model/SegmentFaceResult.cc
View File

@@ -46,14 +46,14 @@ void SegmentFaceResult::parse(const std::string &payload)
Data::Element elementObject;
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
data_.elements.push_back(elementObject);
}

76
imageseg/src/model/SegmentFoodRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentFoodRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentFoodRequest;
SegmentFoodRequest::SegmentFoodRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentFood")
{
setMethod(HttpRequest::Method::Post);
}
SegmentFoodRequest::~SegmentFoodRequest()
{}
std::string SegmentFoodRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentFoodRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentFoodRequest;
SegmentFoodRequest::SegmentFoodRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentFood") {
setMethod(HttpRequest::Method::Post);
}
void SegmentFoodRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentFoodRequest::~SegmentFoodRequest() {}
std::string SegmentFoodRequest::getReturnForm() const {
return returnForm_;
}
std::string SegmentFoodRequest::getImageURL()const
{
return imageURL_;
void SegmentFoodRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentFoodRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentFoodRequest::getOssFile() const {
return ossFile_;
}
void SegmentFoodRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentFoodRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentFoodRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentFoodRequest::getImageURL() const {
return imageURL_;
}
void SegmentFoodRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

64
imageseg/src/model/SegmentFurnitureRequest.cc
View File

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

64
imageseg/src/model/SegmentHDBodyRequest.cc
View File

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

76
imageseg/src/model/SegmentHDCommonImageRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentHDCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHDCommonImageRequest;
SegmentHDCommonImageRequest::SegmentHDCommonImageRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHDCommonImage")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHDCommonImageRequest::~SegmentHDCommonImageRequest()
{}
bool SegmentHDCommonImageRequest::getAsync()const
{
return async_;
*/
#include <alibabacloud/imageseg/model/SegmentHDCommonImageRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHDCommonImageRequest;
SegmentHDCommonImageRequest::SegmentHDCommonImageRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentHDCommonImage") {
setMethod(HttpRequest::Method::Post);
}
void SegmentHDCommonImageRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
SegmentHDCommonImageRequest::~SegmentHDCommonImageRequest() {}
std::string SegmentHDCommonImageRequest::getOssFile() const {
return ossFile_;
}
std::string SegmentHDCommonImageRequest::getImageUrl()const
{
return imageUrl_;
void SegmentHDCommonImageRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
void SegmentHDCommonImageRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
std::string SegmentHDCommonImageRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentHDCommonImageRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
bool SegmentHDCommonImageRequest::getAsync() const {
return async_;
}
void SegmentHDCommonImageRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
std::string SegmentHDCommonImageRequest::getImageUrl() const {
return imageUrl_;
}
void SegmentHDCommonImageRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
}

64
imageseg/src/model/SegmentHDSkyRequest.cc
View File

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

64
imageseg/src/model/SegmentHairRequest.cc
View File

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

8
imageseg/src/model/SegmentHairResult.cc
View File

@@ -46,14 +46,14 @@ void SegmentHairResult::parse(const std::string &payload)
Data::Element elementObject;
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
data_.elements.push_back(elementObject);
}

76
imageseg/src/model/SegmentHeadRequest.cc
View File

@@ -1,51 +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/imageseg/model/SegmentHeadRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHeadRequest;
SegmentHeadRequest::SegmentHeadRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentHead")
{
setMethod(HttpRequest::Method::Post);
}
SegmentHeadRequest::~SegmentHeadRequest()
{}
std::string SegmentHeadRequest::getReturnForm()const
{
return returnForm_;
*/
#include <alibabacloud/imageseg/model/SegmentHeadRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentHeadRequest;
SegmentHeadRequest::SegmentHeadRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentHead") {
setMethod(HttpRequest::Method::Post);
}
void SegmentHeadRequest::setReturnForm(const std::string& returnForm)
{
returnForm_ = returnForm;
setParameter("ReturnForm", returnForm);
SegmentHeadRequest::~SegmentHeadRequest() {}
std::string SegmentHeadRequest::getReturnForm() const {
return returnForm_;
}
std::string SegmentHeadRequest::getImageURL()const
{
return imageURL_;
void SegmentHeadRequest::setReturnForm(const std::string &returnForm) {
returnForm_ = returnForm;
setParameter(std::string("ReturnForm"), returnForm);
}
void SegmentHeadRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string SegmentHeadRequest::getOssFile() const {
return ossFile_;
}
void SegmentHeadRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentHeadRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentHeadRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentHeadRequest::getImageURL() const {
return imageURL_;
}
void SegmentHeadRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

12
imageseg/src/model/SegmentHeadResult.cc
View File

@@ -44,16 +44,16 @@ void SegmentHeadResult::parse(const std::string &payload)
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
if(!dataNodeElementsElement["Width"].isNull())
elementObject.width = std::stoi(dataNodeElementsElement["Width"].asString());
if(!dataNodeElementsElement["Height"].isNull())
elementObject.height = std::stoi(dataNodeElementsElement["Height"].asString());
if(!dataNodeElementsElement["Y"].isNull())
elementObject.y = std::stoi(dataNodeElementsElement["Y"].asString());
if(!dataNodeElementsElement["X"].isNull())
elementObject.x = std::stoi(dataNodeElementsElement["X"].asString());
data_.elements.push_back(elementObject);
}

64
imageseg/src/model/SegmentLogoRequest.cc
View File

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

64
imageseg/src/model/SegmentSceneRequest.cc
View File

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

64
imageseg/src/model/SegmentSkinRequest.cc
View File

@@ -1,40 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageseg/model/SegmentSkinRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentSkinRequest;
SegmentSkinRequest::SegmentSkinRequest() :
RpcServiceRequest("imageseg", "2019-12-30", "SegmentSkin")
{
setMethod(HttpRequest::Method::Post);
}
SegmentSkinRequest::~SegmentSkinRequest()
{}
std::string SegmentSkinRequest::getURL()const
{
return uRL_;
*/
#include <alibabacloud/imageseg/model/SegmentSkinRequest.h>
using AlibabaCloud::Imageseg::Model::SegmentSkinRequest;
SegmentSkinRequest::SegmentSkinRequest()
: RpcServiceRequest("imageseg", "2019-12-30", "SegmentSkin") {
setMethod(HttpRequest::Method::Post);
}
void SegmentSkinRequest::setURL(const std::string& uRL)
{
uRL_ = uRL;
setBodyParameter("URL", uRL);
SegmentSkinRequest::~SegmentSkinRequest() {}
std::string SegmentSkinRequest::getOssFile() const {
return ossFile_;
}
void SegmentSkinRequest::setOssFile(const std::string &ossFile) {
ossFile_ = ossFile;
setParameter(std::string("OssFile"), ossFile);
}
std::string SegmentSkinRequest::getRequestProxyBy() const {
return requestProxyBy_;
}
void SegmentSkinRequest::setRequestProxyBy(const std::string &requestProxyBy) {
requestProxyBy_ = requestProxyBy;
setParameter(std::string("RequestProxyBy"), requestProxyBy);
}
std::string SegmentSkinRequest::getURL() const {
return uRL_;
}
void SegmentSkinRequest::setURL(const std::string &uRL) {
uRL_ = uRL;
setBodyParameter(std::string("URL"), uRL);
}

64
imageseg/src/model/SegmentSkyRequest.cc
View File

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

64
imageseg/src/model/SegmentVehicleRequest.cc
View File

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

4
imageseg/src/model/SegmentVehicleResult.cc
View File

@@ -44,10 +44,10 @@ void SegmentVehicleResult::parse(const std::string &payload)
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["OriginImageURL"].isNull())
elementObject.originImageURL = dataNodeElementsElement["OriginImageURL"].asString();
if(!dataNodeElementsElement["ImageURL"].isNull())
elementObject.imageURL = dataNodeElementsElement["ImageURL"].asString();
if(!dataNodeElementsElement["OriginImageURL"].isNull())
elementObject.originImageURL = dataNodeElementsElement["OriginImageURL"].asString();
data_.elements.push_back(elementObject);
}