imageenhan

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 25, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source 
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap 

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType 

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty 

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient 

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type AssessCompositionRequest 

type AssessCompositionRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

AssessCompositionRequest is the request struct for api AssessComposition

func CreateAssessCompositionRequest 

func CreateAssessCompositionRequest() (request *AssessCompositionRequest)

CreateAssessCompositionRequest creates a request to invoke AssessComposition API

type AssessCompositionResponse 

type AssessCompositionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

AssessCompositionResponse is the response struct for api AssessComposition

func CreateAssessCompositionResponse 

func CreateAssessCompositionResponse() (response *AssessCompositionResponse)

CreateAssessCompositionResponse creates a response to parse from AssessComposition response

type AssessExposureRequest 

type AssessExposureRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

AssessExposureRequest is the request struct for api AssessExposure

func CreateAssessExposureRequest 

func CreateAssessExposureRequest() (request *AssessExposureRequest)

CreateAssessExposureRequest creates a request to invoke AssessExposure API

type AssessExposureResponse 

type AssessExposureResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

AssessExposureResponse is the response struct for api AssessExposure

func CreateAssessExposureResponse 

func CreateAssessExposureResponse() (response *AssessExposureResponse)

CreateAssessExposureResponse creates a response to parse from AssessExposure response

type AssessSharpnessRequest 

type AssessSharpnessRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

AssessSharpnessRequest is the request struct for api AssessSharpness

func CreateAssessSharpnessRequest 

func CreateAssessSharpnessRequest() (request *AssessSharpnessRequest)

CreateAssessSharpnessRequest creates a request to invoke AssessSharpness API

type AssessSharpnessResponse 

type AssessSharpnessResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

AssessSharpnessResponse is the response struct for api AssessSharpness

func CreateAssessSharpnessResponse 

func CreateAssessSharpnessResponse() (response *AssessSharpnessResponse)

CreateAssessSharpnessResponse creates a response to parse from AssessSharpness response

type ChangeImageSizeRequest 

type ChangeImageSizeRequest struct {
	*requests.RpcRequest
	Height requests.Integer `position:"Body" name:"Height"`
	Url    string           `position:"Body" name:"Url"`
	Width  requests.Integer `position:"Body" name:"Width"`
}

ChangeImageSizeRequest is the request struct for api ChangeImageSize

func CreateChangeImageSizeRequest 

func CreateChangeImageSizeRequest() (request *ChangeImageSizeRequest)

CreateChangeImageSizeRequest creates a request to invoke ChangeImageSize API

type ChangeImageSizeResponse 

type ChangeImageSizeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ChangeImageSizeResponse is the response struct for api ChangeImageSize

func CreateChangeImageSizeResponse 

func CreateChangeImageSizeResponse() (response *ChangeImageSizeResponse)

CreateChangeImageSizeResponse creates a response to parse from ChangeImageSize response

type Client 

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient 

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey 

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole 

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions 

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider 

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn 

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy 

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair 

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken 

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) AssessComposition 

func (client *Client) AssessComposition(request *AssessCompositionRequest) (response *AssessCompositionResponse, err error)

AssessComposition invokes the imageenhan.AssessComposition API synchronously

func (*Client) AssessCompositionWithCallback 

func (client *Client) AssessCompositionWithCallback(request *AssessCompositionRequest, callback func(response *AssessCompositionResponse, err error)) <-chan int

AssessCompositionWithCallback invokes the imageenhan.AssessComposition API asynchronously

func (*Client) AssessCompositionWithChan 

func (client *Client) AssessCompositionWithChan(request *AssessCompositionRequest) (<-chan *AssessCompositionResponse, <-chan error)

AssessCompositionWithChan invokes the imageenhan.AssessComposition API asynchronously

func (*Client) AssessExposure 

func (client *Client) AssessExposure(request *AssessExposureRequest) (response *AssessExposureResponse, err error)

AssessExposure invokes the imageenhan.AssessExposure API synchronously

func (*Client) AssessExposureWithCallback 

func (client *Client) AssessExposureWithCallback(request *AssessExposureRequest, callback func(response *AssessExposureResponse, err error)) <-chan int

AssessExposureWithCallback invokes the imageenhan.AssessExposure API asynchronously

func (*Client) AssessExposureWithChan 

func (client *Client) AssessExposureWithChan(request *AssessExposureRequest) (<-chan *AssessExposureResponse, <-chan error)

AssessExposureWithChan invokes the imageenhan.AssessExposure API asynchronously

func (*Client) AssessSharpness 

func (client *Client) AssessSharpness(request *AssessSharpnessRequest) (response *AssessSharpnessResponse, err error)

AssessSharpness invokes the imageenhan.AssessSharpness API synchronously

func (*Client) AssessSharpnessWithCallback 

func (client *Client) AssessSharpnessWithCallback(request *AssessSharpnessRequest, callback func(response *AssessSharpnessResponse, err error)) <-chan int

AssessSharpnessWithCallback invokes the imageenhan.AssessSharpness API asynchronously

func (*Client) AssessSharpnessWithChan 

func (client *Client) AssessSharpnessWithChan(request *AssessSharpnessRequest) (<-chan *AssessSharpnessResponse, <-chan error)

AssessSharpnessWithChan invokes the imageenhan.AssessSharpness API asynchronously

func (*Client) ChangeImageSize 

func (client *Client) ChangeImageSize(request *ChangeImageSizeRequest) (response *ChangeImageSizeResponse, err error)

ChangeImageSize invokes the imageenhan.ChangeImageSize API synchronously

func (*Client) ChangeImageSizeWithCallback 

func (client *Client) ChangeImageSizeWithCallback(request *ChangeImageSizeRequest, callback func(response *ChangeImageSizeResponse, err error)) <-chan int

ChangeImageSizeWithCallback invokes the imageenhan.ChangeImageSize API asynchronously

func (*Client) ChangeImageSizeWithChan 

func (client *Client) ChangeImageSizeWithChan(request *ChangeImageSizeRequest) (<-chan *ChangeImageSizeResponse, <-chan error)

ChangeImageSizeWithChan invokes the imageenhan.ChangeImageSize API asynchronously

func (*Client) ColorizeImage 

func (client *Client) ColorizeImage(request *ColorizeImageRequest) (response *ColorizeImageResponse, err error)

ColorizeImage invokes the imageenhan.ColorizeImage API synchronously

func (*Client) ColorizeImageWithCallback 

func (client *Client) ColorizeImageWithCallback(request *ColorizeImageRequest, callback func(response *ColorizeImageResponse, err error)) <-chan int

ColorizeImageWithCallback invokes the imageenhan.ColorizeImage API asynchronously

func (*Client) ColorizeImageWithChan 

func (client *Client) ColorizeImageWithChan(request *ColorizeImageRequest) (<-chan *ColorizeImageResponse, <-chan error)

ColorizeImageWithChan invokes the imageenhan.ColorizeImage API asynchronously

func (*Client) EnhanceImageColor 

func (client *Client) EnhanceImageColor(request *EnhanceImageColorRequest) (response *EnhanceImageColorResponse, err error)

EnhanceImageColor invokes the imageenhan.EnhanceImageColor API synchronously

func (*Client) EnhanceImageColorWithCallback 

func (client *Client) EnhanceImageColorWithCallback(request *EnhanceImageColorRequest, callback func(response *EnhanceImageColorResponse, err error)) <-chan int

EnhanceImageColorWithCallback invokes the imageenhan.EnhanceImageColor API asynchronously

func (*Client) EnhanceImageColorWithChan 

func (client *Client) EnhanceImageColorWithChan(request *EnhanceImageColorRequest) (<-chan *EnhanceImageColorResponse, <-chan error)

EnhanceImageColorWithChan invokes the imageenhan.EnhanceImageColor API asynchronously

func (*Client) ErasePerson 

func (client *Client) ErasePerson(request *ErasePersonRequest) (response *ErasePersonResponse, err error)

ErasePerson invokes the imageenhan.ErasePerson API synchronously

func (*Client) ErasePersonWithCallback 

func (client *Client) ErasePersonWithCallback(request *ErasePersonRequest, callback func(response *ErasePersonResponse, err error)) <-chan int

ErasePersonWithCallback invokes the imageenhan.ErasePerson API asynchronously

func (*Client) ErasePersonWithChan 

func (client *Client) ErasePersonWithChan(request *ErasePersonRequest) (<-chan *ErasePersonResponse, <-chan error)

ErasePersonWithChan invokes the imageenhan.ErasePerson API asynchronously

func (*Client) ExtendImageStyle 

func (client *Client) ExtendImageStyle(request *ExtendImageStyleRequest) (response *ExtendImageStyleResponse, err error)

ExtendImageStyle invokes the imageenhan.ExtendImageStyle API synchronously

func (*Client) ExtendImageStyleWithCallback 

func (client *Client) ExtendImageStyleWithCallback(request *ExtendImageStyleRequest, callback func(response *ExtendImageStyleResponse, err error)) <-chan int

ExtendImageStyleWithCallback invokes the imageenhan.ExtendImageStyle API asynchronously

func (*Client) ExtendImageStyleWithChan 

func (client *Client) ExtendImageStyleWithChan(request *ExtendImageStyleRequest) (<-chan *ExtendImageStyleResponse, <-chan error)

ExtendImageStyleWithChan invokes the imageenhan.ExtendImageStyle API asynchronously

func (*Client) GenerateDynamicImage 

func (client *Client) GenerateDynamicImage(request *GenerateDynamicImageRequest) (response *GenerateDynamicImageResponse, err error)

GenerateDynamicImage invokes the imageenhan.GenerateDynamicImage API synchronously

func (*Client) GenerateDynamicImageWithCallback 

func (client *Client) GenerateDynamicImageWithCallback(request *GenerateDynamicImageRequest, callback func(response *GenerateDynamicImageResponse, err error)) <-chan int

GenerateDynamicImageWithCallback invokes the imageenhan.GenerateDynamicImage API asynchronously

func (*Client) GenerateDynamicImageWithChan 

func (client *Client) GenerateDynamicImageWithChan(request *GenerateDynamicImageRequest) (<-chan *GenerateDynamicImageResponse, <-chan error)

GenerateDynamicImageWithChan invokes the imageenhan.GenerateDynamicImage API asynchronously

func (*Client) GetAsyncJobResult 

func (client *Client) GetAsyncJobResult(request *GetAsyncJobResultRequest) (response *GetAsyncJobResultResponse, err error)

GetAsyncJobResult invokes the imageenhan.GetAsyncJobResult API synchronously

func (*Client) GetAsyncJobResultWithCallback 

func (client *Client) GetAsyncJobResultWithCallback(request *GetAsyncJobResultRequest, callback func(response *GetAsyncJobResultResponse, err error)) <-chan int

GetAsyncJobResultWithCallback invokes the imageenhan.GetAsyncJobResult API asynchronously

func (*Client) GetAsyncJobResultWithChan 

func (client *Client) GetAsyncJobResultWithChan(request *GetAsyncJobResultRequest) (<-chan *GetAsyncJobResultResponse, <-chan error)

GetAsyncJobResultWithChan invokes the imageenhan.GetAsyncJobResult API asynchronously

func (*Client) ImageBlindCharacterWatermark 

func (client *Client) ImageBlindCharacterWatermark(request *ImageBlindCharacterWatermarkRequest) (response *ImageBlindCharacterWatermarkResponse, err error)

ImageBlindCharacterWatermark invokes the imageenhan.ImageBlindCharacterWatermark API synchronously

func (*Client) ImageBlindCharacterWatermarkWithCallback 

func (client *Client) ImageBlindCharacterWatermarkWithCallback(request *ImageBlindCharacterWatermarkRequest, callback func(response *ImageBlindCharacterWatermarkResponse, err error)) <-chan int

ImageBlindCharacterWatermarkWithCallback invokes the imageenhan.ImageBlindCharacterWatermark API asynchronously

func (*Client) ImageBlindCharacterWatermarkWithChan 

func (client *Client) ImageBlindCharacterWatermarkWithChan(request *ImageBlindCharacterWatermarkRequest) (<-chan *ImageBlindCharacterWatermarkResponse, <-chan error)

ImageBlindCharacterWatermarkWithChan invokes the imageenhan.ImageBlindCharacterWatermark API asynchronously

func (*Client) ImageBlindPicWatermark 

func (client *Client) ImageBlindPicWatermark(request *ImageBlindPicWatermarkRequest) (response *ImageBlindPicWatermarkResponse, err error)

ImageBlindPicWatermark invokes the imageenhan.ImageBlindPicWatermark API synchronously

func (*Client) ImageBlindPicWatermarkWithCallback 

func (client *Client) ImageBlindPicWatermarkWithCallback(request *ImageBlindPicWatermarkRequest, callback func(response *ImageBlindPicWatermarkResponse, err error)) <-chan int

ImageBlindPicWatermarkWithCallback invokes the imageenhan.ImageBlindPicWatermark API asynchronously

func (*Client) ImageBlindPicWatermarkWithChan 

func (client *Client) ImageBlindPicWatermarkWithChan(request *ImageBlindPicWatermarkRequest) (<-chan *ImageBlindPicWatermarkResponse, <-chan error)

ImageBlindPicWatermarkWithChan invokes the imageenhan.ImageBlindPicWatermark API asynchronously

func (*Client) ImitatePhotoStyle 

func (client *Client) ImitatePhotoStyle(request *ImitatePhotoStyleRequest) (response *ImitatePhotoStyleResponse, err error)

ImitatePhotoStyle invokes the imageenhan.ImitatePhotoStyle API synchronously

func (*Client) ImitatePhotoStyleWithCallback 

func (client *Client) ImitatePhotoStyleWithCallback(request *ImitatePhotoStyleRequest, callback func(response *ImitatePhotoStyleResponse, err error)) <-chan int

ImitatePhotoStyleWithCallback invokes the imageenhan.ImitatePhotoStyle API asynchronously

func (*Client) ImitatePhotoStyleWithChan 

func (client *Client) ImitatePhotoStyleWithChan(request *ImitatePhotoStyleRequest) (<-chan *ImitatePhotoStyleResponse, <-chan error)

ImitatePhotoStyleWithChan invokes the imageenhan.ImitatePhotoStyle API asynchronously

func (*Client) IntelligentComposition 

func (client *Client) IntelligentComposition(request *IntelligentCompositionRequest) (response *IntelligentCompositionResponse, err error)

IntelligentComposition invokes the imageenhan.IntelligentComposition API synchronously

func (*Client) IntelligentCompositionWithCallback 

func (client *Client) IntelligentCompositionWithCallback(request *IntelligentCompositionRequest, callback func(response *IntelligentCompositionResponse, err error)) <-chan int

IntelligentCompositionWithCallback invokes the imageenhan.IntelligentComposition API asynchronously

func (*Client) IntelligentCompositionWithChan 

func (client *Client) IntelligentCompositionWithChan(request *IntelligentCompositionRequest) (<-chan *IntelligentCompositionResponse, <-chan error)

IntelligentCompositionWithChan invokes the imageenhan.IntelligentComposition API asynchronously

func (*Client) MakeSuperResolutionImage 

func (client *Client) MakeSuperResolutionImage(request *MakeSuperResolutionImageRequest) (response *MakeSuperResolutionImageResponse, err error)

MakeSuperResolutionImage invokes the imageenhan.MakeSuperResolutionImage API synchronously

func (*Client) MakeSuperResolutionImageWithCallback 

func (client *Client) MakeSuperResolutionImageWithCallback(request *MakeSuperResolutionImageRequest, callback func(response *MakeSuperResolutionImageResponse, err error)) <-chan int

MakeSuperResolutionImageWithCallback invokes the imageenhan.MakeSuperResolutionImage API asynchronously

func (*Client) MakeSuperResolutionImageWithChan 

func (client *Client) MakeSuperResolutionImageWithChan(request *MakeSuperResolutionImageRequest) (<-chan *MakeSuperResolutionImageResponse, <-chan error)

MakeSuperResolutionImageWithChan invokes the imageenhan.MakeSuperResolutionImage API asynchronously

func (*Client) RecolorHDImage 

func (client *Client) RecolorHDImage(request *RecolorHDImageRequest) (response *RecolorHDImageResponse, err error)

RecolorHDImage invokes the imageenhan.RecolorHDImage API synchronously

func (*Client) RecolorHDImageWithCallback 

func (client *Client) RecolorHDImageWithCallback(request *RecolorHDImageRequest, callback func(response *RecolorHDImageResponse, err error)) <-chan int

RecolorHDImageWithCallback invokes the imageenhan.RecolorHDImage API asynchronously

func (*Client) RecolorHDImageWithChan 

func (client *Client) RecolorHDImageWithChan(request *RecolorHDImageRequest) (<-chan *RecolorHDImageResponse, <-chan error)

RecolorHDImageWithChan invokes the imageenhan.RecolorHDImage API asynchronously

func (*Client) RecolorImage 

func (client *Client) RecolorImage(request *RecolorImageRequest) (response *RecolorImageResponse, err error)

RecolorImage invokes the imageenhan.RecolorImage API synchronously

func (*Client) RecolorImageWithCallback 

func (client *Client) RecolorImageWithCallback(request *RecolorImageRequest, callback func(response *RecolorImageResponse, err error)) <-chan int

RecolorImageWithCallback invokes the imageenhan.RecolorImage API asynchronously

func (*Client) RecolorImageWithChan 

func (client *Client) RecolorImageWithChan(request *RecolorImageRequest) (<-chan *RecolorImageResponse, <-chan error)

RecolorImageWithChan invokes the imageenhan.RecolorImage API asynchronously

func (*Client) RemoveImageSubtitles 

func (client *Client) RemoveImageSubtitles(request *RemoveImageSubtitlesRequest) (response *RemoveImageSubtitlesResponse, err error)

RemoveImageSubtitles invokes the imageenhan.RemoveImageSubtitles API synchronously

func (*Client) RemoveImageSubtitlesWithCallback 

func (client *Client) RemoveImageSubtitlesWithCallback(request *RemoveImageSubtitlesRequest, callback func(response *RemoveImageSubtitlesResponse, err error)) <-chan int

RemoveImageSubtitlesWithCallback invokes the imageenhan.RemoveImageSubtitles API asynchronously

func (*Client) RemoveImageSubtitlesWithChan 

func (client *Client) RemoveImageSubtitlesWithChan(request *RemoveImageSubtitlesRequest) (<-chan *RemoveImageSubtitlesResponse, <-chan error)

RemoveImageSubtitlesWithChan invokes the imageenhan.RemoveImageSubtitles API asynchronously

func (*Client) RemoveImageWatermark 

func (client *Client) RemoveImageWatermark(request *RemoveImageWatermarkRequest) (response *RemoveImageWatermarkResponse, err error)

RemoveImageWatermark invokes the imageenhan.RemoveImageWatermark API synchronously

func (*Client) RemoveImageWatermarkWithCallback 

func (client *Client) RemoveImageWatermarkWithCallback(request *RemoveImageWatermarkRequest, callback func(response *RemoveImageWatermarkResponse, err error)) <-chan int

RemoveImageWatermarkWithCallback invokes the imageenhan.RemoveImageWatermark API asynchronously

func (*Client) RemoveImageWatermarkWithChan 

func (client *Client) RemoveImageWatermarkWithChan(request *RemoveImageWatermarkRequest) (<-chan *RemoveImageWatermarkResponse, <-chan error)

RemoveImageWatermarkWithChan invokes the imageenhan.RemoveImageWatermark API asynchronously

type ColorizeImageRequest 

type ColorizeImageRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

ColorizeImageRequest is the request struct for api ColorizeImage

func CreateColorizeImageRequest 

func CreateColorizeImageRequest() (request *ColorizeImageRequest)

CreateColorizeImageRequest creates a request to invoke ColorizeImage API

type ColorizeImageResponse 

type ColorizeImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ColorizeImageResponse is the response struct for api ColorizeImage

func CreateColorizeImageResponse 

func CreateColorizeImageResponse() (response *ColorizeImageResponse)

CreateColorizeImageResponse creates a response to parse from ColorizeImage response

type Data 

type Data struct {
	JobId             string         `json:"JobId" xml:"JobId"`
	MajorUrl          string         `json:"MajorUrl" xml:"MajorUrl"`
	Result            string         `json:"Result" xml:"Result"`
	Sharpness         float64        `json:"Sharpness" xml:"Sharpness"`
	ErrorMessage      string         `json:"ErrorMessage" xml:"ErrorMessage"`
	Score             float64        `json:"Score" xml:"Score"`
	Exposure          float64        `json:"Exposure" xml:"Exposure"`
	Url               string         `json:"Url" xml:"Url"`
	TextImageURL      string         `json:"TextImageURL" xml:"TextImageURL"`
	WatermarkImageURL string         `json:"WatermarkImageURL" xml:"WatermarkImageURL"`
	LogoURL           string         `json:"LogoURL" xml:"LogoURL"`
	ImageUrl          string         `json:"ImageUrl" xml:"ImageUrl"`
	ImageURL          string         `json:"ImageURL" xml:"ImageURL"`
	Status            string         `json:"Status" xml:"Status"`
	ErrorCode         string         `json:"ErrorCode" xml:"ErrorCode"`
	ImageList         []string       `json:"ImageList" xml:"ImageList"`
	RetainLocation    RetainLocation `json:"RetainLocation" xml:"RetainLocation"`
	Elements          []Element      `json:"Elements" xml:"Elements"`
}

Data is a nested struct in imageenhan response

type Element 

type Element struct {
	MinX  int     `json:"MinX" xml:"MinX"`
	Score float64 `json:"Score" xml:"Score"`
	MaxY  int     `json:"MaxY" xml:"MaxY"`
	MaxX  int     `json:"MaxX" xml:"MaxX"`
	MinY  int     `json:"MinY" xml:"MinY"`
}

Element is a nested struct in imageenhan response

type Elements 

type Elements struct {
	Element []Element `json:"Element" xml:"Element"`
}

Elements is a nested struct in imageenhan response

type EnhanceImageColorRequest 

type EnhanceImageColorRequest struct {
	*requests.RpcRequest
	Mode         string `position:"Body" name:"Mode"`
	OutputFormat string `position:"Body" name:"OutputFormat"`
	ImageURL     string `position:"Body" name:"ImageURL"`
}

EnhanceImageColorRequest is the request struct for api EnhanceImageColor

func CreateEnhanceImageColorRequest 

func CreateEnhanceImageColorRequest() (request *EnhanceImageColorRequest)

CreateEnhanceImageColorRequest creates a request to invoke EnhanceImageColor API

type EnhanceImageColorResponse 

type EnhanceImageColorResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnhanceImageColorResponse is the response struct for api EnhanceImageColor

func CreateEnhanceImageColorResponse 

func CreateEnhanceImageColorResponse() (response *EnhanceImageColorResponse)

CreateEnhanceImageColorResponse creates a response to parse from EnhanceImageColor response

type ErasePersonRequest 

type ErasePersonRequest struct {
	*requests.RpcRequest
	UserMask string `position:"Body" name:"UserMask"`
	ImageURL string `position:"Body" name:"ImageURL"`
}

ErasePersonRequest is the request struct for api ErasePerson

func CreateErasePersonRequest 

func CreateErasePersonRequest() (request *ErasePersonRequest)

CreateErasePersonRequest creates a request to invoke ErasePerson API

type ErasePersonResponse 

type ErasePersonResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ErasePersonResponse is the response struct for api ErasePerson

func CreateErasePersonResponse 

func CreateErasePersonResponse() (response *ErasePersonResponse)

CreateErasePersonResponse creates a response to parse from ErasePerson response

type ExtendImageStyleRequest 

type ExtendImageStyleRequest struct {
	*requests.RpcRequest
	MajorUrl string `position:"Body" name:"MajorUrl"`
	StyleUrl string `position:"Body" name:"StyleUrl"`
}

ExtendImageStyleRequest is the request struct for api ExtendImageStyle

func CreateExtendImageStyleRequest 

func CreateExtendImageStyleRequest() (request *ExtendImageStyleRequest)

CreateExtendImageStyleRequest creates a request to invoke ExtendImageStyle API

type ExtendImageStyleResponse 

type ExtendImageStyleResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ExtendImageStyleResponse is the response struct for api ExtendImageStyle

func CreateExtendImageStyleResponse 

func CreateExtendImageStyleResponse() (response *ExtendImageStyleResponse)

CreateExtendImageStyleResponse creates a response to parse from ExtendImageStyle response

type GenerateDynamicImageRequest 

type GenerateDynamicImageRequest struct {
	*requests.RpcRequest
	Url       string `position:"Body" name:"Url"`
	Operation string `position:"Body" name:"Operation"`
}

GenerateDynamicImageRequest is the request struct for api GenerateDynamicImage

func CreateGenerateDynamicImageRequest 

func CreateGenerateDynamicImageRequest() (request *GenerateDynamicImageRequest)

CreateGenerateDynamicImageRequest creates a request to invoke GenerateDynamicImage API

type GenerateDynamicImageResponse 

type GenerateDynamicImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

GenerateDynamicImageResponse is the response struct for api GenerateDynamicImage

func CreateGenerateDynamicImageResponse 

func CreateGenerateDynamicImageResponse() (response *GenerateDynamicImageResponse)

CreateGenerateDynamicImageResponse creates a response to parse from GenerateDynamicImage response

type GetAsyncJobResultRequest 

type GetAsyncJobResultRequest struct {
	*requests.RpcRequest
	JobId string           `position:"Body" name:"JobId"`
	Async requests.Boolean `position:"Body" name:"Async"`
}

GetAsyncJobResultRequest is the request struct for api GetAsyncJobResult

func CreateGetAsyncJobResultRequest 

func CreateGetAsyncJobResultRequest() (request *GetAsyncJobResultRequest)

CreateGetAsyncJobResultRequest creates a request to invoke GetAsyncJobResult API

type GetAsyncJobResultResponse 

type GetAsyncJobResultResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetAsyncJobResultResponse is the response struct for api GetAsyncJobResult

func CreateGetAsyncJobResultResponse 

func CreateGetAsyncJobResultResponse() (response *GetAsyncJobResultResponse)

CreateGetAsyncJobResultResponse creates a response to parse from GetAsyncJobResult response

type ImageBlindCharacterWatermarkRequest 

type ImageBlindCharacterWatermarkRequest struct {
	*requests.RpcRequest
	WatermarkImageURL string           `position:"Body" name:"WatermarkImageURL"`
	OutputFileType    string           `position:"Body" name:"OutputFileType"`
	Text              string           `position:"Body" name:"Text"`
	QualityFactor     requests.Integer `position:"Body" name:"QualityFactor"`
	FunctionType      string           `position:"Body" name:"FunctionType"`
	OriginImageURL    string           `position:"Body" name:"OriginImageURL"`
}

ImageBlindCharacterWatermarkRequest is the request struct for api ImageBlindCharacterWatermark

func CreateImageBlindCharacterWatermarkRequest 

func CreateImageBlindCharacterWatermarkRequest() (request *ImageBlindCharacterWatermarkRequest)

CreateImageBlindCharacterWatermarkRequest creates a request to invoke ImageBlindCharacterWatermark API

type ImageBlindCharacterWatermarkResponse 

type ImageBlindCharacterWatermarkResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ImageBlindCharacterWatermarkResponse is the response struct for api ImageBlindCharacterWatermark

func CreateImageBlindCharacterWatermarkResponse 

func CreateImageBlindCharacterWatermarkResponse() (response *ImageBlindCharacterWatermarkResponse)

CreateImageBlindCharacterWatermarkResponse creates a response to parse from ImageBlindCharacterWatermark response

type ImageBlindPicWatermarkRequest 

type ImageBlindPicWatermarkRequest struct {
	*requests.RpcRequest
	WatermarkImageURL string           `position:"Body" name:"WatermarkImageURL"`
	LogoURL           string           `position:"Body" name:"LogoURL"`
	OutputFileType    string           `position:"Body" name:"OutputFileType"`
	QualityFactor     requests.Integer `position:"Body" name:"QualityFactor"`
	FunctionType      string           `position:"Body" name:"FunctionType"`
	OriginImageURL    string           `position:"Body" name:"OriginImageURL"`
}

ImageBlindPicWatermarkRequest is the request struct for api ImageBlindPicWatermark

func CreateImageBlindPicWatermarkRequest 

func CreateImageBlindPicWatermarkRequest() (request *ImageBlindPicWatermarkRequest)

CreateImageBlindPicWatermarkRequest creates a request to invoke ImageBlindPicWatermark API

type ImageBlindPicWatermarkResponse 

type ImageBlindPicWatermarkResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ImageBlindPicWatermarkResponse is the response struct for api ImageBlindPicWatermark

func CreateImageBlindPicWatermarkResponse 

func CreateImageBlindPicWatermarkResponse() (response *ImageBlindPicWatermarkResponse)

CreateImageBlindPicWatermarkResponse creates a response to parse from ImageBlindPicWatermark response

type ImageListInRecolorHDImage 

type ImageListInRecolorHDImage struct {
	ImageList []string `json:"ImageList" xml:"ImageList"`
}

ImageListInRecolorHDImage is a nested struct in imageenhan response

type ImageListInRecolorImage 

type ImageListInRecolorImage struct {
	ImageList []string `json:"ImageList" xml:"ImageList"`
}

ImageListInRecolorImage is a nested struct in imageenhan response

type ImitatePhotoStyleRequest 

type ImitatePhotoStyleRequest struct {
	*requests.RpcRequest
	StyleUrl string `position:"Body" name:"StyleUrl"`
	ImageURL string `position:"Body" name:"ImageURL"`
}

ImitatePhotoStyleRequest is the request struct for api ImitatePhotoStyle

func CreateImitatePhotoStyleRequest 

func CreateImitatePhotoStyleRequest() (request *ImitatePhotoStyleRequest)

CreateImitatePhotoStyleRequest creates a request to invoke ImitatePhotoStyle API

type ImitatePhotoStyleResponse 

type ImitatePhotoStyleResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

ImitatePhotoStyleResponse is the response struct for api ImitatePhotoStyle

func CreateImitatePhotoStyleResponse 

func CreateImitatePhotoStyleResponse() (response *ImitatePhotoStyleResponse)

CreateImitatePhotoStyleResponse creates a response to parse from ImitatePhotoStyle response

type IntelligentCompositionRequest 

type IntelligentCompositionRequest struct {
	*requests.RpcRequest
	NumBoxes requests.Integer `position:"Body" name:"NumBoxes"`
	ImageURL string           `position:"Body" name:"ImageURL"`
}

IntelligentCompositionRequest is the request struct for api IntelligentComposition

func CreateIntelligentCompositionRequest 

func CreateIntelligentCompositionRequest() (request *IntelligentCompositionRequest)

CreateIntelligentCompositionRequest creates a request to invoke IntelligentComposition API

type IntelligentCompositionResponse 

type IntelligentCompositionResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

IntelligentCompositionResponse is the response struct for api IntelligentComposition

func CreateIntelligentCompositionResponse 

func CreateIntelligentCompositionResponse() (response *IntelligentCompositionResponse)

CreateIntelligentCompositionResponse creates a response to parse from IntelligentComposition response

type MakeSuperResolutionImageRequest 

type MakeSuperResolutionImageRequest struct {
	*requests.RpcRequest
	UpscaleFactor requests.Integer `position:"Body" name:"UpscaleFactor"`
	Mode          string           `position:"Body" name:"Mode"`
	OutputFormat  string           `position:"Body" name:"OutputFormat"`
	Url           string           `position:"Body" name:"Url"`
	OutputQuality requests.Integer `position:"Body" name:"OutputQuality"`
}

MakeSuperResolutionImageRequest is the request struct for api MakeSuperResolutionImage

func CreateMakeSuperResolutionImageRequest 

func CreateMakeSuperResolutionImageRequest() (request *MakeSuperResolutionImageRequest)

CreateMakeSuperResolutionImageRequest creates a request to invoke MakeSuperResolutionImage API

type MakeSuperResolutionImageResponse 

type MakeSuperResolutionImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

MakeSuperResolutionImageResponse is the response struct for api MakeSuperResolutionImage

func CreateMakeSuperResolutionImageResponse 

func CreateMakeSuperResolutionImageResponse() (response *MakeSuperResolutionImageResponse)

CreateMakeSuperResolutionImageResponse creates a response to parse from MakeSuperResolutionImage response

type RecolorHDImageColorTemplate 

type RecolorHDImageColorTemplate struct {
	Color string `name:"Color"`
}

RecolorHDImageColorTemplate is a repeated param struct in RecolorHDImageRequest

type RecolorHDImageRequest 

type RecolorHDImageRequest struct {
	*requests.RpcRequest
	Mode          string                         `position:"Body" name:"Mode"`
	ColorCount    requests.Integer               `position:"Body" name:"ColorCount"`
	ColorTemplate *[]RecolorHDImageColorTemplate `position:"Body" name:"ColorTemplate"  type:"Repeated"`
	Degree        string                         `position:"Body" name:"Degree"`
	Url           string                         `position:"Body" name:"Url"`
	Async         requests.Boolean               `position:"Body" name:"Async"`
	RefUrl        string                         `position:"Body" name:"RefUrl"`
}

RecolorHDImageRequest is the request struct for api RecolorHDImage

func CreateRecolorHDImageRequest 

func CreateRecolorHDImageRequest() (request *RecolorHDImageRequest)

CreateRecolorHDImageRequest creates a request to invoke RecolorHDImage API

type RecolorHDImageResponse 

type RecolorHDImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecolorHDImageResponse is the response struct for api RecolorHDImage

func CreateRecolorHDImageResponse 

func CreateRecolorHDImageResponse() (response *RecolorHDImageResponse)

CreateRecolorHDImageResponse creates a response to parse from RecolorHDImage response

type RecolorImageColorTemplate 

type RecolorImageColorTemplate struct {
	Color string `name:"Color"`
}

RecolorImageColorTemplate is a repeated param struct in RecolorImageRequest

type RecolorImageRequest 

type RecolorImageRequest struct {
	*requests.RpcRequest
	Mode          string                       `position:"Body" name:"Mode"`
	ColorCount    requests.Integer             `position:"Body" name:"ColorCount"`
	ColorTemplate *[]RecolorImageColorTemplate `position:"Body" name:"ColorTemplate"  type:"Repeated"`
	Url           string                       `position:"Body" name:"Url"`
	RefUrl        string                       `position:"Body" name:"RefUrl"`
}

RecolorImageRequest is the request struct for api RecolorImage

func CreateRecolorImageRequest 

func CreateRecolorImageRequest() (request *RecolorImageRequest)

CreateRecolorImageRequest creates a request to invoke RecolorImage API

type RecolorImageResponse 

type RecolorImageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RecolorImageResponse is the response struct for api RecolorImage

func CreateRecolorImageResponse 

func CreateRecolorImageResponse() (response *RecolorImageResponse)

CreateRecolorImageResponse creates a response to parse from RecolorImage response

type RemoveImageSubtitlesRequest 

type RemoveImageSubtitlesRequest struct {
	*requests.RpcRequest
	BH       requests.Float `position:"Body" name:"BH"`
	BW       requests.Float `position:"Body" name:"BW"`
	BX       requests.Float `position:"Body" name:"BX"`
	BY       requests.Float `position:"Body" name:"BY"`
	ImageURL string         `position:"Body" name:"ImageURL"`
}

RemoveImageSubtitlesRequest is the request struct for api RemoveImageSubtitles

func CreateRemoveImageSubtitlesRequest 

func CreateRemoveImageSubtitlesRequest() (request *RemoveImageSubtitlesRequest)

CreateRemoveImageSubtitlesRequest creates a request to invoke RemoveImageSubtitles API

type RemoveImageSubtitlesResponse 

type RemoveImageSubtitlesResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RemoveImageSubtitlesResponse is the response struct for api RemoveImageSubtitles

func CreateRemoveImageSubtitlesResponse 

func CreateRemoveImageSubtitlesResponse() (response *RemoveImageSubtitlesResponse)

CreateRemoveImageSubtitlesResponse creates a response to parse from RemoveImageSubtitles response

type RemoveImageWatermarkRequest 

type RemoveImageWatermarkRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Body" name:"ImageURL"`
}

RemoveImageWatermarkRequest is the request struct for api RemoveImageWatermark

func CreateRemoveImageWatermarkRequest 

func CreateRemoveImageWatermarkRequest() (request *RemoveImageWatermarkRequest)

CreateRemoveImageWatermarkRequest creates a request to invoke RemoveImageWatermark API

type RemoveImageWatermarkResponse 

type RemoveImageWatermarkResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      Data   `json:"Data" xml:"Data"`
}

RemoveImageWatermarkResponse is the response struct for api RemoveImageWatermark

func CreateRemoveImageWatermarkResponse 

func CreateRemoveImageWatermarkResponse() (response *RemoveImageWatermarkResponse)

CreateRemoveImageWatermarkResponse creates a response to parse from RemoveImageWatermark response

type RetainLocation 

type RetainLocation struct {
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Y      int `json:"Y" xml:"Y"`
	X      int `json:"X" xml:"X"`
}

RetainLocation is a nested struct in imageenhan response

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.