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

Update MakeSuperResolutionImage.

Browse Source
This commit is contained in:
sdk-team
2022-12-09 07:54:28 +00:00
parent e0dbc50d2f
commit d4e14749ca
39 changed files with 1307 additions and 1577 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionRequest : public RpcServiceRequest
{
public:
AssessCompositionRequest();
~AssessCompositionRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionRequest : public RpcServiceRequest {
public:
AssessCompositionRequest();
~AssessCompositionRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONREQUEST_H_

68
imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureRequest : public RpcServiceRequest
{
public:
AssessExposureRequest();
~AssessExposureRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureRequest : public RpcServiceRequest {
public:
AssessExposureRequest();
~AssessExposureRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSUREREQUEST_H_

68
imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessRequest : public RpcServiceRequest
{
public:
AssessSharpnessRequest();
~AssessSharpnessRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessRequest : public RpcServiceRequest {
public:
AssessSharpnessRequest();
~AssessSharpnessRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSREQUEST_H_

80
imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h
View File

@@ -1,54 +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_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeRequest : public RpcServiceRequest
{
public:
ChangeImageSizeRequest();
~ChangeImageSizeRequest();
int getHeight()const;
void setHeight(int height);
std::string getUrl()const;
void setUrl(const std::string& url);
int getWidth()const;
void setWidth(int width);
private:
int height_;
std::string url_;
int width_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeRequest : public RpcServiceRequest {
public:
ChangeImageSizeRequest();
~ChangeImageSizeRequest();
int getHeight() const;
void setHeight(int height);
std::string getUrl() const;
void setUrl(const std::string &url);
int getWidth() const;
void setWidth(int width);
private:
int height_;
std::string url_;
int width_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_

68
imageenhan/include/alibabacloud/imageenhan/model/ColorizeImageRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ColorizeImageRequest : public RpcServiceRequest
{
public:
ColorizeImageRequest();
~ColorizeImageRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ColorizeImageRequest : public RpcServiceRequest {
public:
ColorizeImageRequest();
~ColorizeImageRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_COLORIZEIMAGEREQUEST_H_

80
imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h
View File

@@ -1,54 +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_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorRequest : public RpcServiceRequest
{
public:
EnhanceImageColorRequest();
~EnhanceImageColorRequest();
std::string getMode()const;
void setMode(const std::string& mode);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string mode_;
std::string outputFormat_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorRequest : public RpcServiceRequest {
public:
EnhanceImageColorRequest();
~EnhanceImageColorRequest();
std::string getMode() const;
void setMode(const std::string &mode);
std::string getOutputFormat() const;
void setOutputFormat(const std::string &outputFormat);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string mode_;
std::string outputFormat_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/ErasePersonRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ErasePersonRequest : public RpcServiceRequest
{
public:
ErasePersonRequest();
~ErasePersonRequest();
std::string getUserMask()const;
void setUserMask(const std::string& userMask);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string userMask_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ErasePersonRequest : public RpcServiceRequest {
public:
ErasePersonRequest();
~ErasePersonRequest();
std::string getUserMask() const;
void setUserMask(const std::string &userMask);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string userMask_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ERASEPERSONREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleRequest : public RpcServiceRequest
{
public:
ExtendImageStyleRequest();
~ExtendImageStyleRequest();
std::string getMajorUrl()const;
void setMajorUrl(const std::string& majorUrl);
std::string getStyleUrl()const;
void setStyleUrl(const std::string& styleUrl);
private:
std::string majorUrl_;
std::string styleUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleRequest : public RpcServiceRequest {
public:
ExtendImageStyleRequest();
~ExtendImageStyleRequest();
std::string getMajorUrl() const;
void setMajorUrl(const std::string &majorUrl);
std::string getStyleUrl() const;
void setStyleUrl(const std::string &styleUrl);
private:
std::string majorUrl_;
std::string styleUrl_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageRequest : public RpcServiceRequest
{
public:
GenerateDynamicImageRequest();
~GenerateDynamicImageRequest();
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getOperation()const;
void setOperation(const std::string& operation);
private:
std::string url_;
std::string operation_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageRequest : public RpcServiceRequest {
public:
GenerateDynamicImageRequest();
~GenerateDynamicImageRequest();
std::string getUrl() const;
void setUrl(const std::string &url);
std::string getOperation() const;
void setOperation(const std::string &operation);
private:
std::string url_;
std::string operation_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
std::string getJobId()const;
void setJobId(const std::string& jobId);
bool getAsync()const;
void setAsync(bool async);
private:
std::string jobId_;
bool async_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
std::string getJobId() const;
void setJobId(const std::string &jobId);
bool getAsync() const;
void setAsync(bool async);
private:
std::string jobId_;
bool async_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_

98
imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h
View File

@@ -1,63 +1,57 @@
/*
* 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_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkRequest : public RpcServiceRequest
{
public:
ImageBlindCharacterWatermarkRequest();
~ImageBlindCharacterWatermarkRequest();
std::string getWatermarkImageURL()const;
void setWatermarkImageURL(const std::string& watermarkImageURL);
std::string getOutputFileType()const;
void setOutputFileType(const std::string& outputFileType);
std::string getText()const;
void setText(const std::string& text);
int getQualityFactor()const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType()const;
void setFunctionType(const std::string& functionType);
std::string getOriginImageURL()const;
void setOriginImageURL(const std::string& originImageURL);
private:
std::string watermarkImageURL_;
std::string outputFileType_;
std::string text_;
int qualityFactor_;
std::string functionType_;
std::string originImageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkRequest : public RpcServiceRequest {
public:
ImageBlindCharacterWatermarkRequest();
~ImageBlindCharacterWatermarkRequest();
std::string getWatermarkImageURL() const;
void setWatermarkImageURL(const std::string &watermarkImageURL);
std::string getOutputFileType() const;
void setOutputFileType(const std::string &outputFileType);
std::string getText() const;
void setText(const std::string &text);
int getQualityFactor() const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType() const;
void setFunctionType(const std::string &functionType);
std::string getOriginImageURL() const;
void setOriginImageURL(const std::string &originImageURL);
private:
std::string watermarkImageURL_;
std::string outputFileType_;
std::string text_;
int qualityFactor_;
std::string functionType_;
std::string originImageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_

98
imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h
View File

@@ -1,63 +1,57 @@
/*
* 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_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkRequest : public RpcServiceRequest
{
public:
ImageBlindPicWatermarkRequest();
~ImageBlindPicWatermarkRequest();
std::string getWatermarkImageURL()const;
void setWatermarkImageURL(const std::string& watermarkImageURL);
std::string getLogoURL()const;
void setLogoURL(const std::string& logoURL);
std::string getOutputFileType()const;
void setOutputFileType(const std::string& outputFileType);
int getQualityFactor()const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType()const;
void setFunctionType(const std::string& functionType);
std::string getOriginImageURL()const;
void setOriginImageURL(const std::string& originImageURL);
private:
std::string watermarkImageURL_;
std::string logoURL_;
std::string outputFileType_;
int qualityFactor_;
std::string functionType_;
std::string originImageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkRequest : public RpcServiceRequest {
public:
ImageBlindPicWatermarkRequest();
~ImageBlindPicWatermarkRequest();
std::string getWatermarkImageURL() const;
void setWatermarkImageURL(const std::string &watermarkImageURL);
std::string getLogoURL() const;
void setLogoURL(const std::string &logoURL);
std::string getOutputFileType() const;
void setOutputFileType(const std::string &outputFileType);
int getQualityFactor() const;
void setQualityFactor(int qualityFactor);
std::string getFunctionType() const;
void setFunctionType(const std::string &functionType);
std::string getOriginImageURL() const;
void setOriginImageURL(const std::string &originImageURL);
private:
std::string watermarkImageURL_;
std::string logoURL_;
std::string outputFileType_;
int qualityFactor_;
std::string functionType_;
std::string originImageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleRequest : public RpcServiceRequest
{
public:
ImitatePhotoStyleRequest();
~ImitatePhotoStyleRequest();
std::string getStyleUrl()const;
void setStyleUrl(const std::string& styleUrl);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string styleUrl_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleRequest : public RpcServiceRequest {
public:
ImitatePhotoStyleRequest();
~ImitatePhotoStyleRequest();
std::string getStyleUrl() const;
void setStyleUrl(const std::string &styleUrl);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string styleUrl_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_

74
imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT IntelligentCompositionRequest : public RpcServiceRequest
{
public:
IntelligentCompositionRequest();
~IntelligentCompositionRequest();
int getNumBoxes()const;
void setNumBoxes(int numBoxes);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int numBoxes_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT IntelligentCompositionRequest : public RpcServiceRequest {
public:
IntelligentCompositionRequest();
~IntelligentCompositionRequest();
int getNumBoxes() const;
void setNumBoxes(int numBoxes);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int numBoxes_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_

92
imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT MakeSuperResolutionImageRequest : public RpcServiceRequest
{
public:
MakeSuperResolutionImageRequest();
~MakeSuperResolutionImageRequest();
long getUpscaleFactor()const;
void setUpscaleFactor(long upscaleFactor);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
std::string getUrl()const;
void setUrl(const std::string& url);
long getOutputQuality()const;
void setOutputQuality(long outputQuality);
private:
long upscaleFactor_;
std::string mode_;
std::string outputFormat_;
std::string url_;
long outputQuality_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT MakeSuperResolutionImageRequest : public RpcServiceRequest {
public:
MakeSuperResolutionImageRequest();
~MakeSuperResolutionImageRequest();
long getUpscaleFactor() const;
void setUpscaleFactor(long upscaleFactor);
std::string getMode() const;
void setMode(const std::string &mode);
std::string getOutputFormat() const;
void setOutputFormat(const std::string &outputFormat);
std::string getUrl() const;
void setUrl(const std::string &url);
long getOutputQuality() const;
void setOutputQuality(long outputQuality);
private:
long upscaleFactor_;
std::string mode_;
std::string outputFormat_;
std::string url_;
long outputQuality_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGEREQUEST_H_

112
imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h
View File

@@ -1,71 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageRequest : public RpcServiceRequest
{
public:
struct ColorTemplate
{
std::string color;
};
public:
RecolorHDImageRequest();
~RecolorHDImageRequest();
std::string getMode()const;
void setMode(const std::string& mode);
int getColorCount()const;
void setColorCount(int colorCount);
std::vector<ColorTemplate> getColorTemplate()const;
void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
std::string getDegree()const;
void setDegree(const std::string& degree);
std::string getUrl()const;
void setUrl(const std::string& url);
bool getAsync()const;
void setAsync(bool async);
std::string getRefUrl()const;
void setRefUrl(const std::string& refUrl);
private:
std::string mode_;
int colorCount_;
std::vector<ColorTemplate> colorTemplate_;
std::string degree_;
std::string url_;
bool async_;
std::string refUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageRequest : public RpcServiceRequest {
public:
struct ColorTemplate {
std::string color;
};
RecolorHDImageRequest();
~RecolorHDImageRequest();
std::string getMode() const;
void setMode(const std::string &mode);
int getColorCount() const;
void setColorCount(int colorCount);
std::vector<ColorTemplate> getColorTemplate() const;
void setColorTemplate(const std::vector<ColorTemplate> &colorTemplate);
std::string getDegree() const;
void setDegree(const std::string &degree);
std::string getUrl() const;
void setUrl(const std::string &url);
bool getAsync() const;
void setAsync(bool async);
std::string getRefUrl() const;
void setRefUrl(const std::string &refUrl);
private:
std::string mode_;
int colorCount_;
std::vector<ColorTemplate> colorTemplate_;
std::string degree_;
std::string url_;
bool async_;
std::string refUrl_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_

100
imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h
View File

@@ -1,65 +1,57 @@
/*
* 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_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageRequest : public RpcServiceRequest
{
public:
struct ColorTemplate
{
std::string color;
};
public:
RecolorImageRequest();
~RecolorImageRequest();
std::string getMode()const;
void setMode(const std::string& mode);
int getColorCount()const;
void setColorCount(int colorCount);
std::vector<ColorTemplate> getColorTemplate()const;
void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
std::string getUrl()const;
void setUrl(const std::string& url);
std::string getRefUrl()const;
void setRefUrl(const std::string& refUrl);
private:
std::string mode_;
int colorCount_;
std::vector<ColorTemplate> colorTemplate_;
std::string url_;
std::string refUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageRequest : public RpcServiceRequest {
public:
struct ColorTemplate {
std::string color;
};
RecolorImageRequest();
~RecolorImageRequest();
std::string getMode() const;
void setMode(const std::string &mode);
int getColorCount() const;
void setColorCount(int colorCount);
std::vector<ColorTemplate> getColorTemplate() const;
void setColorTemplate(const std::vector<ColorTemplate> &colorTemplate);
std::string getUrl() const;
void setUrl(const std::string &url);
std::string getRefUrl() const;
void setRefUrl(const std::string &refUrl);
private:
std::string mode_;
int colorCount_;
std::vector<ColorTemplate> colorTemplate_;
std::string url_;
std::string refUrl_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_

92
imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesRequest : public RpcServiceRequest
{
public:
RemoveImageSubtitlesRequest();
~RemoveImageSubtitlesRequest();
float getBH()const;
void setBH(float bH);
float getBW()const;
void setBW(float bW);
float getBX()const;
void setBX(float bX);
float getBY()const;
void setBY(float bY);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
float bH_;
float bW_;
float bX_;
float bY_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesRequest : public RpcServiceRequest {
public:
RemoveImageSubtitlesRequest();
~RemoveImageSubtitlesRequest();
float getBH() const;
void setBH(float bH);
float getBW() const;
void setBW(float bW);
float getBX() const;
void setBX(float bX);
float getBY() const;
void setBY(float bY);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
float bH_;
float bW_;
float bX_;
float bY_;
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_

68
imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/imageenhan/ImageenhanExport.h>
namespace AlibabaCloud
{
namespace Imageenhan
{
namespace Model
{
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageWatermarkRequest : public RpcServiceRequest
{
public:
RemoveImageWatermarkRequest();
~RemoveImageWatermarkRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
*/
#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_
#include <alibabacloud/imageenhan/ImageenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Imageenhan {
namespace Model {
class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageWatermarkRequest : public RpcServiceRequest {
public:
RemoveImageWatermarkRequest();
~RemoveImageWatermarkRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Imageenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKREQUEST_H_

46
imageenhan/src/model/AssessCompositionRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/imageenhan/model/AssessCompositionRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessCompositionRequest;
AssessCompositionRequest::AssessCompositionRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "AssessComposition")
{
setMethod(HttpRequest::Method::Post);
}
AssessCompositionRequest::~AssessCompositionRequest()
{}
std::string AssessCompositionRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/imageenhan/model/AssessCompositionRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessCompositionRequest;
AssessCompositionRequest::AssessCompositionRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "AssessComposition") {
setMethod(HttpRequest::Method::Post);
}
void AssessCompositionRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
AssessCompositionRequest::~AssessCompositionRequest() {}
std::string AssessCompositionRequest::getImageURL() const {
return imageURL_;
}
void AssessCompositionRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
imageenhan/src/model/AssessExposureRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/imageenhan/model/AssessExposureRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessExposureRequest;
AssessExposureRequest::AssessExposureRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "AssessExposure")
{
setMethod(HttpRequest::Method::Post);
}
AssessExposureRequest::~AssessExposureRequest()
{}
std::string AssessExposureRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/imageenhan/model/AssessExposureRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessExposureRequest;
AssessExposureRequest::AssessExposureRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "AssessExposure") {
setMethod(HttpRequest::Method::Post);
}
void AssessExposureRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
AssessExposureRequest::~AssessExposureRequest() {}
std::string AssessExposureRequest::getImageURL() const {
return imageURL_;
}
void AssessExposureRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
imageenhan/src/model/AssessSharpnessRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/imageenhan/model/AssessSharpnessRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessSharpnessRequest;
AssessSharpnessRequest::AssessSharpnessRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "AssessSharpness")
{
setMethod(HttpRequest::Method::Post);
}
AssessSharpnessRequest::~AssessSharpnessRequest()
{}
std::string AssessSharpnessRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/imageenhan/model/AssessSharpnessRequest.h>
using AlibabaCloud::Imageenhan::Model::AssessSharpnessRequest;
AssessSharpnessRequest::AssessSharpnessRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "AssessSharpness") {
setMethod(HttpRequest::Method::Post);
}
void AssessSharpnessRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
AssessSharpnessRequest::~AssessSharpnessRequest() {}
std::string AssessSharpnessRequest::getImageURL() const {
return imageURL_;
}
void AssessSharpnessRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
imageenhan/src/model/ChangeImageSizeRequest.cc
View File

@@ -1,62 +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/imageenhan/model/ChangeImageSizeRequest.h>
using AlibabaCloud::Imageenhan::Model::ChangeImageSizeRequest;
ChangeImageSizeRequest::ChangeImageSizeRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ChangeImageSize")
{
setMethod(HttpRequest::Method::Post);
}
ChangeImageSizeRequest::~ChangeImageSizeRequest()
{}
int ChangeImageSizeRequest::getHeight()const
{
return height_;
*/
#include <alibabacloud/imageenhan/model/ChangeImageSizeRequest.h>
using AlibabaCloud::Imageenhan::Model::ChangeImageSizeRequest;
ChangeImageSizeRequest::ChangeImageSizeRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ChangeImageSize") {
setMethod(HttpRequest::Method::Post);
}
void ChangeImageSizeRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
ChangeImageSizeRequest::~ChangeImageSizeRequest() {}
int ChangeImageSizeRequest::getHeight() const {
return height_;
}
std::string ChangeImageSizeRequest::getUrl()const
{
return url_;
void ChangeImageSizeRequest::setHeight(int height) {
height_ = height;
setBodyParameter(std::string("Height"), std::to_string(height));
}
void ChangeImageSizeRequest::setUrl(const std::string& url)
{
url_ = url;
setBodyParameter("Url", url);
std::string ChangeImageSizeRequest::getUrl() const {
return url_;
}
int ChangeImageSizeRequest::getWidth()const
{
return width_;
void ChangeImageSizeRequest::setUrl(const std::string &url) {
url_ = url;
setBodyParameter(std::string("Url"), url);
}
void ChangeImageSizeRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
int ChangeImageSizeRequest::getWidth() const {
return width_;
}
void ChangeImageSizeRequest::setWidth(int width) {
width_ = width;
setBodyParameter(std::string("Width"), std::to_string(width));
}

46
imageenhan/src/model/ColorizeImageRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/imageenhan/model/ColorizeImageRequest.h>
using AlibabaCloud::Imageenhan::Model::ColorizeImageRequest;
ColorizeImageRequest::ColorizeImageRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ColorizeImage")
{
setMethod(HttpRequest::Method::Post);
}
ColorizeImageRequest::~ColorizeImageRequest()
{}
std::string ColorizeImageRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/imageenhan/model/ColorizeImageRequest.h>
using AlibabaCloud::Imageenhan::Model::ColorizeImageRequest;
ColorizeImageRequest::ColorizeImageRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ColorizeImage") {
setMethod(HttpRequest::Method::Post);
}
void ColorizeImageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
ColorizeImageRequest::~ColorizeImageRequest() {}
std::string ColorizeImageRequest::getImageURL() const {
return imageURL_;
}
void ColorizeImageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
imageenhan/src/model/EnhanceImageColorRequest.cc
View File

@@ -1,62 +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/imageenhan/model/EnhanceImageColorRequest.h>
using AlibabaCloud::Imageenhan::Model::EnhanceImageColorRequest;
EnhanceImageColorRequest::EnhanceImageColorRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "EnhanceImageColor")
{
setMethod(HttpRequest::Method::Post);
}
EnhanceImageColorRequest::~EnhanceImageColorRequest()
{}
std::string EnhanceImageColorRequest::getMode()const
{
return mode_;
*/
#include <alibabacloud/imageenhan/model/EnhanceImageColorRequest.h>
using AlibabaCloud::Imageenhan::Model::EnhanceImageColorRequest;
EnhanceImageColorRequest::EnhanceImageColorRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "EnhanceImageColor") {
setMethod(HttpRequest::Method::Post);
}
void EnhanceImageColorRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
EnhanceImageColorRequest::~EnhanceImageColorRequest() {}
std::string EnhanceImageColorRequest::getMode() const {
return mode_;
}
std::string EnhanceImageColorRequest::getOutputFormat()const
{
return outputFormat_;
void EnhanceImageColorRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
void EnhanceImageColorRequest::setOutputFormat(const std::string& outputFormat)
{
outputFormat_ = outputFormat;
setBodyParameter("OutputFormat", outputFormat);
std::string EnhanceImageColorRequest::getOutputFormat() const {
return outputFormat_;
}
std::string EnhanceImageColorRequest::getImageURL()const
{
return imageURL_;
void EnhanceImageColorRequest::setOutputFormat(const std::string &outputFormat) {
outputFormat_ = outputFormat;
setBodyParameter(std::string("OutputFormat"), outputFormat);
}
void EnhanceImageColorRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string EnhanceImageColorRequest::getImageURL() const {
return imageURL_;
}
void EnhanceImageColorRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
imageenhan/src/model/ErasePersonRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/ErasePersonRequest.h>
using AlibabaCloud::Imageenhan::Model::ErasePersonRequest;
ErasePersonRequest::ErasePersonRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ErasePerson")
{
setMethod(HttpRequest::Method::Post);
}
ErasePersonRequest::~ErasePersonRequest()
{}
std::string ErasePersonRequest::getUserMask()const
{
return userMask_;
*/
#include <alibabacloud/imageenhan/model/ErasePersonRequest.h>
using AlibabaCloud::Imageenhan::Model::ErasePersonRequest;
ErasePersonRequest::ErasePersonRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ErasePerson") {
setMethod(HttpRequest::Method::Post);
}
void ErasePersonRequest::setUserMask(const std::string& userMask)
{
userMask_ = userMask;
setBodyParameter("UserMask", userMask);
ErasePersonRequest::~ErasePersonRequest() {}
std::string ErasePersonRequest::getUserMask() const {
return userMask_;
}
std::string ErasePersonRequest::getImageURL()const
{
return imageURL_;
void ErasePersonRequest::setUserMask(const std::string &userMask) {
userMask_ = userMask;
setBodyParameter(std::string("UserMask"), userMask);
}
void ErasePersonRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string ErasePersonRequest::getImageURL() const {
return imageURL_;
}
void ErasePersonRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
imageenhan/src/model/ExtendImageStyleRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/ExtendImageStyleRequest.h>
using AlibabaCloud::Imageenhan::Model::ExtendImageStyleRequest;
ExtendImageStyleRequest::ExtendImageStyleRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ExtendImageStyle")
{
setMethod(HttpRequest::Method::Post);
}
ExtendImageStyleRequest::~ExtendImageStyleRequest()
{}
std::string ExtendImageStyleRequest::getMajorUrl()const
{
return majorUrl_;
*/
#include <alibabacloud/imageenhan/model/ExtendImageStyleRequest.h>
using AlibabaCloud::Imageenhan::Model::ExtendImageStyleRequest;
ExtendImageStyleRequest::ExtendImageStyleRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ExtendImageStyle") {
setMethod(HttpRequest::Method::Post);
}
void ExtendImageStyleRequest::setMajorUrl(const std::string& majorUrl)
{
majorUrl_ = majorUrl;
setBodyParameter("MajorUrl", majorUrl);
ExtendImageStyleRequest::~ExtendImageStyleRequest() {}
std::string ExtendImageStyleRequest::getMajorUrl() const {
return majorUrl_;
}
std::string ExtendImageStyleRequest::getStyleUrl()const
{
return styleUrl_;
void ExtendImageStyleRequest::setMajorUrl(const std::string &majorUrl) {
majorUrl_ = majorUrl;
setBodyParameter(std::string("MajorUrl"), majorUrl);
}
void ExtendImageStyleRequest::setStyleUrl(const std::string& styleUrl)
{
styleUrl_ = styleUrl;
setBodyParameter("StyleUrl", styleUrl);
std::string ExtendImageStyleRequest::getStyleUrl() const {
return styleUrl_;
}
void ExtendImageStyleRequest::setStyleUrl(const std::string &styleUrl) {
styleUrl_ = styleUrl;
setBodyParameter(std::string("StyleUrl"), styleUrl);
}

58
imageenhan/src/model/GenerateDynamicImageRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/GenerateDynamicImageRequest.h>
using AlibabaCloud::Imageenhan::Model::GenerateDynamicImageRequest;
GenerateDynamicImageRequest::GenerateDynamicImageRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "GenerateDynamicImage")
{
setMethod(HttpRequest::Method::Post);
}
GenerateDynamicImageRequest::~GenerateDynamicImageRequest()
{}
std::string GenerateDynamicImageRequest::getUrl()const
{
return url_;
*/
#include <alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h>
using AlibabaCloud::Imageenhan::Model::GenerateDynamicImageRequest;
GenerateDynamicImageRequest::GenerateDynamicImageRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "GenerateDynamicImage") {
setMethod(HttpRequest::Method::Post);
}
void GenerateDynamicImageRequest::setUrl(const std::string& url)
{
url_ = url;
setBodyParameter("Url", url);
GenerateDynamicImageRequest::~GenerateDynamicImageRequest() {}
std::string GenerateDynamicImageRequest::getUrl() const {
return url_;
}
std::string GenerateDynamicImageRequest::getOperation()const
{
return operation_;
void GenerateDynamicImageRequest::setUrl(const std::string &url) {
url_ = url;
setBodyParameter(std::string("Url"), url);
}
void GenerateDynamicImageRequest::setOperation(const std::string& operation)
{
operation_ = operation;
setBodyParameter("Operation", operation);
std::string GenerateDynamicImageRequest::getOperation() const {
return operation_;
}
void GenerateDynamicImageRequest::setOperation(const std::string &operation) {
operation_ = operation;
setBodyParameter(std::string("Operation"), operation);
}

58
imageenhan/src/model/GetAsyncJobResultRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Imageenhan::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "GetAsyncJobResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
{}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Imageenhan::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "GetAsyncJobResult") {
setMethod(HttpRequest::Method::Post);
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
std::string GetAsyncJobResultRequest::getJobId() const {
return jobId_;
}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setBodyParameter(std::string("JobId"), jobId);
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool GetAsyncJobResultRequest::getAsync() const {
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}

106
imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc
View File

@@ -1,95 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::ImageBlindCharacterWatermarkRequest;
ImageBlindCharacterWatermarkRequest::ImageBlindCharacterWatermarkRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindCharacterWatermark")
{
setMethod(HttpRequest::Method::Post);
}
ImageBlindCharacterWatermarkRequest::~ImageBlindCharacterWatermarkRequest()
{}
std::string ImageBlindCharacterWatermarkRequest::getWatermarkImageURL()const
{
return watermarkImageURL_;
*/
#include <alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::ImageBlindCharacterWatermarkRequest;
ImageBlindCharacterWatermarkRequest::ImageBlindCharacterWatermarkRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindCharacterWatermark") {
setMethod(HttpRequest::Method::Post);
}
void ImageBlindCharacterWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL)
{
watermarkImageURL_ = watermarkImageURL;
setBodyParameter("WatermarkImageURL", watermarkImageURL);
ImageBlindCharacterWatermarkRequest::~ImageBlindCharacterWatermarkRequest() {}
std::string ImageBlindCharacterWatermarkRequest::getWatermarkImageURL() const {
return watermarkImageURL_;
}
std::string ImageBlindCharacterWatermarkRequest::getOutputFileType()const
{
return outputFileType_;
void ImageBlindCharacterWatermarkRequest::setWatermarkImageURL(const std::string &watermarkImageURL) {
watermarkImageURL_ = watermarkImageURL;
setBodyParameter(std::string("WatermarkImageURL"), watermarkImageURL);
}
void ImageBlindCharacterWatermarkRequest::setOutputFileType(const std::string& outputFileType)
{
outputFileType_ = outputFileType;
setBodyParameter("OutputFileType", outputFileType);
std::string ImageBlindCharacterWatermarkRequest::getOutputFileType() const {
return outputFileType_;
}
std::string ImageBlindCharacterWatermarkRequest::getText()const
{
return text_;
void ImageBlindCharacterWatermarkRequest::setOutputFileType(const std::string &outputFileType) {
outputFileType_ = outputFileType;
setBodyParameter(std::string("OutputFileType"), outputFileType);
}
void ImageBlindCharacterWatermarkRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
std::string ImageBlindCharacterWatermarkRequest::getText() const {
return text_;
}
int ImageBlindCharacterWatermarkRequest::getQualityFactor()const
{
return qualityFactor_;
void ImageBlindCharacterWatermarkRequest::setText(const std::string &text) {
text_ = text;
setBodyParameter(std::string("Text"), text);
}
void ImageBlindCharacterWatermarkRequest::setQualityFactor(int qualityFactor)
{
qualityFactor_ = qualityFactor;
setBodyParameter("QualityFactor", std::to_string(qualityFactor));
int ImageBlindCharacterWatermarkRequest::getQualityFactor() const {
return qualityFactor_;
}
std::string ImageBlindCharacterWatermarkRequest::getFunctionType()const
{
return functionType_;
void ImageBlindCharacterWatermarkRequest::setQualityFactor(int qualityFactor) {
qualityFactor_ = qualityFactor;
setBodyParameter(std::string("QualityFactor"), std::to_string(qualityFactor));
}
void ImageBlindCharacterWatermarkRequest::setFunctionType(const std::string& functionType)
{
functionType_ = functionType;
setBodyParameter("FunctionType", functionType);
std::string ImageBlindCharacterWatermarkRequest::getFunctionType() const {
return functionType_;
}
std::string ImageBlindCharacterWatermarkRequest::getOriginImageURL()const
{
return originImageURL_;
void ImageBlindCharacterWatermarkRequest::setFunctionType(const std::string &functionType) {
functionType_ = functionType;
setBodyParameter(std::string("FunctionType"), functionType);
}
void ImageBlindCharacterWatermarkRequest::setOriginImageURL(const std::string& originImageURL)
{
originImageURL_ = originImageURL;
setBodyParameter("OriginImageURL", originImageURL);
std::string ImageBlindCharacterWatermarkRequest::getOriginImageURL() const {
return originImageURL_;
}
void ImageBlindCharacterWatermarkRequest::setOriginImageURL(const std::string &originImageURL) {
originImageURL_ = originImageURL;
setBodyParameter(std::string("OriginImageURL"), originImageURL);
}

106
imageenhan/src/model/ImageBlindPicWatermarkRequest.cc
View File

@@ -1,95 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::ImageBlindPicWatermarkRequest;
ImageBlindPicWatermarkRequest::ImageBlindPicWatermarkRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindPicWatermark")
{
setMethod(HttpRequest::Method::Post);
}
ImageBlindPicWatermarkRequest::~ImageBlindPicWatermarkRequest()
{}
std::string ImageBlindPicWatermarkRequest::getWatermarkImageURL()const
{
return watermarkImageURL_;
*/
#include <alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::ImageBlindPicWatermarkRequest;
ImageBlindPicWatermarkRequest::ImageBlindPicWatermarkRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindPicWatermark") {
setMethod(HttpRequest::Method::Post);
}
void ImageBlindPicWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL)
{
watermarkImageURL_ = watermarkImageURL;
setBodyParameter("WatermarkImageURL", watermarkImageURL);
ImageBlindPicWatermarkRequest::~ImageBlindPicWatermarkRequest() {}
std::string ImageBlindPicWatermarkRequest::getWatermarkImageURL() const {
return watermarkImageURL_;
}
std::string ImageBlindPicWatermarkRequest::getLogoURL()const
{
return logoURL_;
void ImageBlindPicWatermarkRequest::setWatermarkImageURL(const std::string &watermarkImageURL) {
watermarkImageURL_ = watermarkImageURL;
setBodyParameter(std::string("WatermarkImageURL"), watermarkImageURL);
}
void ImageBlindPicWatermarkRequest::setLogoURL(const std::string& logoURL)
{
logoURL_ = logoURL;
setBodyParameter("LogoURL", logoURL);
std::string ImageBlindPicWatermarkRequest::getLogoURL() const {
return logoURL_;
}
std::string ImageBlindPicWatermarkRequest::getOutputFileType()const
{
return outputFileType_;
void ImageBlindPicWatermarkRequest::setLogoURL(const std::string &logoURL) {
logoURL_ = logoURL;
setBodyParameter(std::string("LogoURL"), logoURL);
}
void ImageBlindPicWatermarkRequest::setOutputFileType(const std::string& outputFileType)
{
outputFileType_ = outputFileType;
setBodyParameter("OutputFileType", outputFileType);
std::string ImageBlindPicWatermarkRequest::getOutputFileType() const {
return outputFileType_;
}
int ImageBlindPicWatermarkRequest::getQualityFactor()const
{
return qualityFactor_;
void ImageBlindPicWatermarkRequest::setOutputFileType(const std::string &outputFileType) {
outputFileType_ = outputFileType;
setBodyParameter(std::string("OutputFileType"), outputFileType);
}
void ImageBlindPicWatermarkRequest::setQualityFactor(int qualityFactor)
{
qualityFactor_ = qualityFactor;
setBodyParameter("QualityFactor", std::to_string(qualityFactor));
int ImageBlindPicWatermarkRequest::getQualityFactor() const {
return qualityFactor_;
}
std::string ImageBlindPicWatermarkRequest::getFunctionType()const
{
return functionType_;
void ImageBlindPicWatermarkRequest::setQualityFactor(int qualityFactor) {
qualityFactor_ = qualityFactor;
setBodyParameter(std::string("QualityFactor"), std::to_string(qualityFactor));
}
void ImageBlindPicWatermarkRequest::setFunctionType(const std::string& functionType)
{
functionType_ = functionType;
setBodyParameter("FunctionType", functionType);
std::string ImageBlindPicWatermarkRequest::getFunctionType() const {
return functionType_;
}
std::string ImageBlindPicWatermarkRequest::getOriginImageURL()const
{
return originImageURL_;
void ImageBlindPicWatermarkRequest::setFunctionType(const std::string &functionType) {
functionType_ = functionType;
setBodyParameter(std::string("FunctionType"), functionType);
}
void ImageBlindPicWatermarkRequest::setOriginImageURL(const std::string& originImageURL)
{
originImageURL_ = originImageURL;
setBodyParameter("OriginImageURL", originImageURL);
std::string ImageBlindPicWatermarkRequest::getOriginImageURL() const {
return originImageURL_;
}
void ImageBlindPicWatermarkRequest::setOriginImageURL(const std::string &originImageURL) {
originImageURL_ = originImageURL;
setBodyParameter(std::string("OriginImageURL"), originImageURL);
}

58
imageenhan/src/model/ImitatePhotoStyleRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/ImitatePhotoStyleRequest.h>
using AlibabaCloud::Imageenhan::Model::ImitatePhotoStyleRequest;
ImitatePhotoStyleRequest::ImitatePhotoStyleRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "ImitatePhotoStyle")
{
setMethod(HttpRequest::Method::Post);
}
ImitatePhotoStyleRequest::~ImitatePhotoStyleRequest()
{}
std::string ImitatePhotoStyleRequest::getStyleUrl()const
{
return styleUrl_;
*/
#include <alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h>
using AlibabaCloud::Imageenhan::Model::ImitatePhotoStyleRequest;
ImitatePhotoStyleRequest::ImitatePhotoStyleRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "ImitatePhotoStyle") {
setMethod(HttpRequest::Method::Post);
}
void ImitatePhotoStyleRequest::setStyleUrl(const std::string& styleUrl)
{
styleUrl_ = styleUrl;
setBodyParameter("StyleUrl", styleUrl);
ImitatePhotoStyleRequest::~ImitatePhotoStyleRequest() {}
std::string ImitatePhotoStyleRequest::getStyleUrl() const {
return styleUrl_;
}
std::string ImitatePhotoStyleRequest::getImageURL()const
{
return imageURL_;
void ImitatePhotoStyleRequest::setStyleUrl(const std::string &styleUrl) {
styleUrl_ = styleUrl;
setBodyParameter(std::string("StyleUrl"), styleUrl);
}
void ImitatePhotoStyleRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string ImitatePhotoStyleRequest::getImageURL() const {
return imageURL_;
}
void ImitatePhotoStyleRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
imageenhan/src/model/IntelligentCompositionRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* 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/imageenhan/model/IntelligentCompositionRequest.h>
using AlibabaCloud::Imageenhan::Model::IntelligentCompositionRequest;
IntelligentCompositionRequest::IntelligentCompositionRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "IntelligentComposition")
{
setMethod(HttpRequest::Method::Post);
}
IntelligentCompositionRequest::~IntelligentCompositionRequest()
{}
int IntelligentCompositionRequest::getNumBoxes()const
{
return numBoxes_;
*/
#include <alibabacloud/imageenhan/model/IntelligentCompositionRequest.h>
using AlibabaCloud::Imageenhan::Model::IntelligentCompositionRequest;
IntelligentCompositionRequest::IntelligentCompositionRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "IntelligentComposition") {
setMethod(HttpRequest::Method::Post);
}
void IntelligentCompositionRequest::setNumBoxes(int numBoxes)
{
numBoxes_ = numBoxes;
setBodyParameter("NumBoxes", std::to_string(numBoxes));
IntelligentCompositionRequest::~IntelligentCompositionRequest() {}
int IntelligentCompositionRequest::getNumBoxes() const {
return numBoxes_;
}
std::string IntelligentCompositionRequest::getImageURL()const
{
return imageURL_;
void IntelligentCompositionRequest::setNumBoxes(int numBoxes) {
numBoxes_ = numBoxes;
setBodyParameter(std::string("NumBoxes"), std::to_string(numBoxes));
}
void IntelligentCompositionRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string IntelligentCompositionRequest::getImageURL() const {
return imageURL_;
}
void IntelligentCompositionRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

94
imageenhan/src/model/MakeSuperResolutionImageRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h>
using AlibabaCloud::Imageenhan::Model::MakeSuperResolutionImageRequest;
MakeSuperResolutionImageRequest::MakeSuperResolutionImageRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "MakeSuperResolutionImage")
{
setMethod(HttpRequest::Method::Post);
}
MakeSuperResolutionImageRequest::~MakeSuperResolutionImageRequest()
{}
long MakeSuperResolutionImageRequest::getUpscaleFactor()const
{
return upscaleFactor_;
*/
#include <alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h>
using AlibabaCloud::Imageenhan::Model::MakeSuperResolutionImageRequest;
MakeSuperResolutionImageRequest::MakeSuperResolutionImageRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "MakeSuperResolutionImage") {
setMethod(HttpRequest::Method::Post);
}
void MakeSuperResolutionImageRequest::setUpscaleFactor(long upscaleFactor)
{
upscaleFactor_ = upscaleFactor;
setBodyParameter("UpscaleFactor", std::to_string(upscaleFactor));
MakeSuperResolutionImageRequest::~MakeSuperResolutionImageRequest() {}
long MakeSuperResolutionImageRequest::getUpscaleFactor() const {
return upscaleFactor_;
}
std::string MakeSuperResolutionImageRequest::getMode()const
{
return mode_;
void MakeSuperResolutionImageRequest::setUpscaleFactor(long upscaleFactor) {
upscaleFactor_ = upscaleFactor;
setBodyParameter(std::string("UpscaleFactor"), std::to_string(upscaleFactor));
}
void MakeSuperResolutionImageRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
std::string MakeSuperResolutionImageRequest::getMode() const {
return mode_;
}
std::string MakeSuperResolutionImageRequest::getOutputFormat()const
{
return outputFormat_;
void MakeSuperResolutionImageRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
void MakeSuperResolutionImageRequest::setOutputFormat(const std::string& outputFormat)
{
outputFormat_ = outputFormat;
setBodyParameter("OutputFormat", outputFormat);
std::string MakeSuperResolutionImageRequest::getOutputFormat() const {
return outputFormat_;
}
std::string MakeSuperResolutionImageRequest::getUrl()const
{
return url_;
void MakeSuperResolutionImageRequest::setOutputFormat(const std::string &outputFormat) {
outputFormat_ = outputFormat;
setBodyParameter(std::string("OutputFormat"), outputFormat);
}
void MakeSuperResolutionImageRequest::setUrl(const std::string& url)
{
url_ = url;
setBodyParameter("Url", url);
std::string MakeSuperResolutionImageRequest::getUrl() const {
return url_;
}
long MakeSuperResolutionImageRequest::getOutputQuality()const
{
return outputQuality_;
void MakeSuperResolutionImageRequest::setUrl(const std::string &url) {
url_ = url;
setBodyParameter(std::string("Url"), url);
}
void MakeSuperResolutionImageRequest::setOutputQuality(long outputQuality)
{
outputQuality_ = outputQuality;
setBodyParameter("OutputQuality", std::to_string(outputQuality));
long MakeSuperResolutionImageRequest::getOutputQuality() const {
return outputQuality_;
}
void MakeSuperResolutionImageRequest::setOutputQuality(long outputQuality) {
outputQuality_ = outputQuality;
setBodyParameter(std::string("OutputQuality"), std::to_string(outputQuality));
}

126
imageenhan/src/model/RecolorHDImageRequest.cc
View File

@@ -1,110 +1,94 @@
/*
* 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/imageenhan/model/RecolorHDImageRequest.h>
using AlibabaCloud::Imageenhan::Model::RecolorHDImageRequest;
RecolorHDImageRequest::RecolorHDImageRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "RecolorHDImage")
{
setMethod(HttpRequest::Method::Post);
}
RecolorHDImageRequest::~RecolorHDImageRequest()
{}
std::string RecolorHDImageRequest::getMode()const
{
return mode_;
*/
#include <alibabacloud/imageenhan/model/RecolorHDImageRequest.h>
using AlibabaCloud::Imageenhan::Model::RecolorHDImageRequest;
RecolorHDImageRequest::RecolorHDImageRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "RecolorHDImage") {
setMethod(HttpRequest::Method::Post);
}
void RecolorHDImageRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
RecolorHDImageRequest::~RecolorHDImageRequest() {}
std::string RecolorHDImageRequest::getMode() const {
return mode_;
}
int RecolorHDImageRequest::getColorCount()const
{
return colorCount_;
void RecolorHDImageRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
void RecolorHDImageRequest::setColorCount(int colorCount)
{
colorCount_ = colorCount;
setBodyParameter("ColorCount", std::to_string(colorCount));
int RecolorHDImageRequest::getColorCount() const {
return colorCount_;
}
std::vector<RecolorHDImageRequest::ColorTemplate> RecolorHDImageRequest::getColorTemplate()const
{
return colorTemplate_;
void RecolorHDImageRequest::setColorCount(int colorCount) {
colorCount_ = colorCount;
setBodyParameter(std::string("ColorCount"), std::to_string(colorCount));
}
void RecolorHDImageRequest::setColorTemplate(const std::vector<ColorTemplate>& colorTemplate)
{
colorTemplate_ = colorTemplate;
for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) {
auto colorTemplateObj = colorTemplate.at(dep1);
std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1);
setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
}
std::vector<RecolorHDImageRequest::ColorTemplate> RecolorHDImageRequest::getColorTemplate() const {
return colorTemplate_;
}
std::string RecolorHDImageRequest::getDegree()const
{
return degree_;
void RecolorHDImageRequest::setColorTemplate(const std::vector<RecolorHDImageRequest::ColorTemplate> &colorTemplate) {
colorTemplate_ = colorTemplate;
for(int dep1 = 0; dep1 != colorTemplate.size(); dep1++) {
auto colorTemplateObj = colorTemplate.at(dep1);
std::string colorTemplateObjStr = std::string("ColorTemplate") + "." + std::to_string(dep1 + 1);
setBodyParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
}
}
void RecolorHDImageRequest::setDegree(const std::string& degree)
{
degree_ = degree;
setBodyParameter("Degree", degree);
std::string RecolorHDImageRequest::getDegree() const {
return degree_;
}
std::string RecolorHDImageRequest::getUrl()const
{
return url_;
void RecolorHDImageRequest::setDegree(const std::string &degree) {
degree_ = degree;
setBodyParameter(std::string("Degree"), degree);
}
void RecolorHDImageRequest::setUrl(const std::string& url)
{
url_ = url;
setBodyParameter("Url", url);
std::string RecolorHDImageRequest::getUrl() const {
return url_;
}
bool RecolorHDImageRequest::getAsync()const
{
return async_;
void RecolorHDImageRequest::setUrl(const std::string &url) {
url_ = url;
setBodyParameter(std::string("Url"), url);
}
void RecolorHDImageRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool RecolorHDImageRequest::getAsync() const {
return async_;
}
std::string RecolorHDImageRequest::getRefUrl()const
{
return refUrl_;
void RecolorHDImageRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void RecolorHDImageRequest::setRefUrl(const std::string& refUrl)
{
refUrl_ = refUrl;
setBodyParameter("RefUrl", refUrl);
std::string RecolorHDImageRequest::getRefUrl() const {
return refUrl_;
}
void RecolorHDImageRequest::setRefUrl(const std::string &refUrl) {
refUrl_ = refUrl;
setBodyParameter(std::string("RefUrl"), refUrl);
}

102
imageenhan/src/model/RecolorImageRequest.cc
View File

@@ -1,88 +1,76 @@
/*
* 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/imageenhan/model/RecolorImageRequest.h>
using AlibabaCloud::Imageenhan::Model::RecolorImageRequest;
RecolorImageRequest::RecolorImageRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "RecolorImage")
{
setMethod(HttpRequest::Method::Post);
}
RecolorImageRequest::~RecolorImageRequest()
{}
std::string RecolorImageRequest::getMode()const
{
return mode_;
*/
#include <alibabacloud/imageenhan/model/RecolorImageRequest.h>
using AlibabaCloud::Imageenhan::Model::RecolorImageRequest;
RecolorImageRequest::RecolorImageRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "RecolorImage") {
setMethod(HttpRequest::Method::Post);
}
void RecolorImageRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
RecolorImageRequest::~RecolorImageRequest() {}
std::string RecolorImageRequest::getMode() const {
return mode_;
}
int RecolorImageRequest::getColorCount()const
{
return colorCount_;
void RecolorImageRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
void RecolorImageRequest::setColorCount(int colorCount)
{
colorCount_ = colorCount;
setBodyParameter("ColorCount", std::to_string(colorCount));
int RecolorImageRequest::getColorCount() const {
return colorCount_;
}
std::vector<RecolorImageRequest::ColorTemplate> RecolorImageRequest::getColorTemplate()const
{
return colorTemplate_;
void RecolorImageRequest::setColorCount(int colorCount) {
colorCount_ = colorCount;
setBodyParameter(std::string("ColorCount"), std::to_string(colorCount));
}
void RecolorImageRequest::setColorTemplate(const std::vector<ColorTemplate>& colorTemplate)
{
colorTemplate_ = colorTemplate;
for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) {
auto colorTemplateObj = colorTemplate.at(dep1);
std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1);
setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
}
std::vector<RecolorImageRequest::ColorTemplate> RecolorImageRequest::getColorTemplate() const {
return colorTemplate_;
}
std::string RecolorImageRequest::getUrl()const
{
return url_;
void RecolorImageRequest::setColorTemplate(const std::vector<RecolorImageRequest::ColorTemplate> &colorTemplate) {
colorTemplate_ = colorTemplate;
for(int dep1 = 0; dep1 != colorTemplate.size(); dep1++) {
auto colorTemplateObj = colorTemplate.at(dep1);
std::string colorTemplateObjStr = std::string("ColorTemplate") + "." + std::to_string(dep1 + 1);
setBodyParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
}
}
void RecolorImageRequest::setUrl(const std::string& url)
{
url_ = url;
setBodyParameter("Url", url);
std::string RecolorImageRequest::getUrl() const {
return url_;
}
std::string RecolorImageRequest::getRefUrl()const
{
return refUrl_;
void RecolorImageRequest::setUrl(const std::string &url) {
url_ = url;
setBodyParameter(std::string("Url"), url);
}
void RecolorImageRequest::setRefUrl(const std::string& refUrl)
{
refUrl_ = refUrl;
setBodyParameter("RefUrl", refUrl);
std::string RecolorImageRequest::getRefUrl() const {
return refUrl_;
}
void RecolorImageRequest::setRefUrl(const std::string &refUrl) {
refUrl_ = refUrl;
setBodyParameter(std::string("RefUrl"), refUrl);
}

94
imageenhan/src/model/RemoveImageSubtitlesRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h>
using AlibabaCloud::Imageenhan::Model::RemoveImageSubtitlesRequest;
RemoveImageSubtitlesRequest::RemoveImageSubtitlesRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageSubtitles")
{
setMethod(HttpRequest::Method::Post);
}
RemoveImageSubtitlesRequest::~RemoveImageSubtitlesRequest()
{}
float RemoveImageSubtitlesRequest::getBH()const
{
return bH_;
*/
#include <alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h>
using AlibabaCloud::Imageenhan::Model::RemoveImageSubtitlesRequest;
RemoveImageSubtitlesRequest::RemoveImageSubtitlesRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageSubtitles") {
setMethod(HttpRequest::Method::Post);
}
void RemoveImageSubtitlesRequest::setBH(float bH)
{
bH_ = bH;
setBodyParameter("BH", std::to_string(bH));
RemoveImageSubtitlesRequest::~RemoveImageSubtitlesRequest() {}
float RemoveImageSubtitlesRequest::getBH() const {
return bH_;
}
float RemoveImageSubtitlesRequest::getBW()const
{
return bW_;
void RemoveImageSubtitlesRequest::setBH(float bH) {
bH_ = bH;
setBodyParameter(std::string("BH"), std::to_string(bH));
}
void RemoveImageSubtitlesRequest::setBW(float bW)
{
bW_ = bW;
setBodyParameter("BW", std::to_string(bW));
float RemoveImageSubtitlesRequest::getBW() const {
return bW_;
}
float RemoveImageSubtitlesRequest::getBX()const
{
return bX_;
void RemoveImageSubtitlesRequest::setBW(float bW) {
bW_ = bW;
setBodyParameter(std::string("BW"), std::to_string(bW));
}
void RemoveImageSubtitlesRequest::setBX(float bX)
{
bX_ = bX;
setBodyParameter("BX", std::to_string(bX));
float RemoveImageSubtitlesRequest::getBX() const {
return bX_;
}
float RemoveImageSubtitlesRequest::getBY()const
{
return bY_;
void RemoveImageSubtitlesRequest::setBX(float bX) {
bX_ = bX;
setBodyParameter(std::string("BX"), std::to_string(bX));
}
void RemoveImageSubtitlesRequest::setBY(float bY)
{
bY_ = bY;
setBodyParameter("BY", std::to_string(bY));
float RemoveImageSubtitlesRequest::getBY() const {
return bY_;
}
std::string RemoveImageSubtitlesRequest::getImageURL()const
{
return imageURL_;
void RemoveImageSubtitlesRequest::setBY(float bY) {
bY_ = bY;
setBodyParameter(std::string("BY"), std::to_string(bY));
}
void RemoveImageSubtitlesRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RemoveImageSubtitlesRequest::getImageURL() const {
return imageURL_;
}
void RemoveImageSubtitlesRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
imageenhan/src/model/RemoveImageWatermarkRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* 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/imageenhan/model/RemoveImageWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::RemoveImageWatermarkRequest;
RemoveImageWatermarkRequest::RemoveImageWatermarkRequest() :
RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageWatermark")
{
setMethod(HttpRequest::Method::Post);
}
RemoveImageWatermarkRequest::~RemoveImageWatermarkRequest()
{}
std::string RemoveImageWatermarkRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h>
using AlibabaCloud::Imageenhan::Model::RemoveImageWatermarkRequest;
RemoveImageWatermarkRequest::RemoveImageWatermarkRequest()
: RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageWatermark") {
setMethod(HttpRequest::Method::Post);
}
void RemoveImageWatermarkRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RemoveImageWatermarkRequest::~RemoveImageWatermarkRequest() {}
std::string RemoveImageWatermarkRequest::getImageURL() const {
return imageURL_;
}
void RemoveImageWatermarkRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}