imageseg

package
v1.61.1631 Latest Latest
Warning

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

 Go to latest Published: Jun 9, 2022 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 ChangeSkyRequest added in v1.61.483 

type ChangeSkyRequest struct {
	*requests.RpcRequest
	ReplaceImageURL string `position:"Query" name:"ReplaceImageURL"`
	ImageURL        string `position:"Query" name:"ImageURL"`
}

ChangeSkyRequest is the request struct for api ChangeSky

func CreateChangeSkyRequest added in v1.61.483 

func CreateChangeSkyRequest() (request *ChangeSkyRequest)

CreateChangeSkyRequest creates a request to invoke ChangeSky API

type ChangeSkyResponse added in v1.61.483 

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

ChangeSkyResponse is the response struct for api ChangeSky

func CreateChangeSkyResponse added in v1.61.483 

func CreateChangeSkyResponse() (response *ChangeSkyResponse)

CreateChangeSkyResponse creates a response to parse from ChangeSky 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) ChangeSky added in v1.61.483 

func (client *Client) ChangeSky(request *ChangeSkyRequest) (response *ChangeSkyResponse, err error)

ChangeSky invokes the imageseg.ChangeSky API synchronously

func (*Client) ChangeSkyWithCallback added in v1.61.483 

func (client *Client) ChangeSkyWithCallback(request *ChangeSkyRequest, callback func(response *ChangeSkyResponse, err error)) <-chan int

ChangeSkyWithCallback invokes the imageseg.ChangeSky API asynchronously

func (*Client) ChangeSkyWithChan added in v1.61.483 

func (client *Client) ChangeSkyWithChan(request *ChangeSkyRequest) (<-chan *ChangeSkyResponse, <-chan error)

ChangeSkyWithChan invokes the imageseg.ChangeSky API asynchronously

func (*Client) GetAsyncJobResult 

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

GetAsyncJobResult invokes the imageseg.GetAsyncJobResult API synchronously

func (*Client) GetAsyncJobResultWithCallback 

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

GetAsyncJobResultWithCallback invokes the imageseg.GetAsyncJobResult API asynchronously

func (*Client) GetAsyncJobResultWithChan 

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

GetAsyncJobResultWithChan invokes the imageseg.GetAsyncJobResult API asynchronously

func (*Client) ParseFace 

func (client *Client) ParseFace(request *ParseFaceRequest) (response *ParseFaceResponse, err error)

ParseFace invokes the imageseg.ParseFace API synchronously

func (*Client) ParseFaceWithCallback 

func (client *Client) ParseFaceWithCallback(request *ParseFaceRequest, callback func(response *ParseFaceResponse, err error)) <-chan int

ParseFaceWithCallback invokes the imageseg.ParseFace API asynchronously

func (*Client) ParseFaceWithChan 

func (client *Client) ParseFaceWithChan(request *ParseFaceRequest) (<-chan *ParseFaceResponse, <-chan error)

ParseFaceWithChan invokes the imageseg.ParseFace API asynchronously

func (*Client) RefineMask 

func (client *Client) RefineMask(request *RefineMaskRequest) (response *RefineMaskResponse, err error)

RefineMask invokes the imageseg.RefineMask API synchronously

func (*Client) RefineMaskWithCallback 

func (client *Client) RefineMaskWithCallback(request *RefineMaskRequest, callback func(response *RefineMaskResponse, err error)) <-chan int

RefineMaskWithCallback invokes the imageseg.RefineMask API asynchronously

func (*Client) RefineMaskWithChan 

func (client *Client) RefineMaskWithChan(request *RefineMaskRequest) (<-chan *RefineMaskResponse, <-chan error)

RefineMaskWithChan invokes the imageseg.RefineMask API asynchronously

func (*Client) SegmentAnimal 

func (client *Client) SegmentAnimal(request *SegmentAnimalRequest) (response *SegmentAnimalResponse, err error)

SegmentAnimal invokes the imageseg.SegmentAnimal API synchronously

func (*Client) SegmentAnimalWithCallback 

func (client *Client) SegmentAnimalWithCallback(request *SegmentAnimalRequest, callback func(response *SegmentAnimalResponse, err error)) <-chan int

SegmentAnimalWithCallback invokes the imageseg.SegmentAnimal API asynchronously

func (*Client) SegmentAnimalWithChan 

func (client *Client) SegmentAnimalWithChan(request *SegmentAnimalRequest) (<-chan *SegmentAnimalResponse, <-chan error)

SegmentAnimalWithChan invokes the imageseg.SegmentAnimal API asynchronously

func (*Client) SegmentBody 

func (client *Client) SegmentBody(request *SegmentBodyRequest) (response *SegmentBodyResponse, err error)

SegmentBody invokes the imageseg.SegmentBody API synchronously

func (*Client) SegmentBodyWithCallback 

func (client *Client) SegmentBodyWithCallback(request *SegmentBodyRequest, callback func(response *SegmentBodyResponse, err error)) <-chan int

SegmentBodyWithCallback invokes the imageseg.SegmentBody API asynchronously

func (*Client) SegmentBodyWithChan 

func (client *Client) SegmentBodyWithChan(request *SegmentBodyRequest) (<-chan *SegmentBodyResponse, <-chan error)

SegmentBodyWithChan invokes the imageseg.SegmentBody API asynchronously

func (*Client) SegmentCloth 

func (client *Client) SegmentCloth(request *SegmentClothRequest) (response *SegmentClothResponse, err error)

SegmentCloth invokes the imageseg.SegmentCloth API synchronously

func (*Client) SegmentClothWithCallback 

func (client *Client) SegmentClothWithCallback(request *SegmentClothRequest, callback func(response *SegmentClothResponse, err error)) <-chan int

SegmentClothWithCallback invokes the imageseg.SegmentCloth API asynchronously

func (*Client) SegmentClothWithChan 

func (client *Client) SegmentClothWithChan(request *SegmentClothRequest) (<-chan *SegmentClothResponse, <-chan error)

SegmentClothWithChan invokes the imageseg.SegmentCloth API asynchronously

func (*Client) SegmentCommodity 

func (client *Client) SegmentCommodity(request *SegmentCommodityRequest) (response *SegmentCommodityResponse, err error)

SegmentCommodity invokes the imageseg.SegmentCommodity API synchronously

func (*Client) SegmentCommodityWithCallback 

func (client *Client) SegmentCommodityWithCallback(request *SegmentCommodityRequest, callback func(response *SegmentCommodityResponse, err error)) <-chan int

SegmentCommodityWithCallback invokes the imageseg.SegmentCommodity API asynchronously

func (*Client) SegmentCommodityWithChan 

func (client *Client) SegmentCommodityWithChan(request *SegmentCommodityRequest) (<-chan *SegmentCommodityResponse, <-chan error)

SegmentCommodityWithChan invokes the imageseg.SegmentCommodity API asynchronously

func (*Client) SegmentCommonImage 

func (client *Client) SegmentCommonImage(request *SegmentCommonImageRequest) (response *SegmentCommonImageResponse, err error)

SegmentCommonImage invokes the imageseg.SegmentCommonImage API synchronously

func (*Client) SegmentCommonImageWithCallback 

func (client *Client) SegmentCommonImageWithCallback(request *SegmentCommonImageRequest, callback func(response *SegmentCommonImageResponse, err error)) <-chan int

SegmentCommonImageWithCallback invokes the imageseg.SegmentCommonImage API asynchronously

func (*Client) SegmentCommonImageWithChan 

func (client *Client) SegmentCommonImageWithChan(request *SegmentCommonImageRequest) (<-chan *SegmentCommonImageResponse, <-chan error)

SegmentCommonImageWithChan invokes the imageseg.SegmentCommonImage API asynchronously

func (*Client) SegmentFace 

func (client *Client) SegmentFace(request *SegmentFaceRequest) (response *SegmentFaceResponse, err error)

SegmentFace invokes the imageseg.SegmentFace API synchronously

func (*Client) SegmentFaceWithCallback 

func (client *Client) SegmentFaceWithCallback(request *SegmentFaceRequest, callback func(response *SegmentFaceResponse, err error)) <-chan int

SegmentFaceWithCallback invokes the imageseg.SegmentFace API asynchronously

func (*Client) SegmentFaceWithChan 

func (client *Client) SegmentFaceWithChan(request *SegmentFaceRequest) (<-chan *SegmentFaceResponse, <-chan error)

SegmentFaceWithChan invokes the imageseg.SegmentFace API asynchronously

func (*Client) SegmentFood 

func (client *Client) SegmentFood(request *SegmentFoodRequest) (response *SegmentFoodResponse, err error)

SegmentFood invokes the imageseg.SegmentFood API synchronously

func (*Client) SegmentFoodWithCallback 

func (client *Client) SegmentFoodWithCallback(request *SegmentFoodRequest, callback func(response *SegmentFoodResponse, err error)) <-chan int

SegmentFoodWithCallback invokes the imageseg.SegmentFood API asynchronously

func (*Client) SegmentFoodWithChan 

func (client *Client) SegmentFoodWithChan(request *SegmentFoodRequest) (<-chan *SegmentFoodResponse, <-chan error)

SegmentFoodWithChan invokes the imageseg.SegmentFood API asynchronously

func (*Client) SegmentFurniture 

func (client *Client) SegmentFurniture(request *SegmentFurnitureRequest) (response *SegmentFurnitureResponse, err error)

SegmentFurniture invokes the imageseg.SegmentFurniture API synchronously

func (*Client) SegmentFurnitureWithCallback 

func (client *Client) SegmentFurnitureWithCallback(request *SegmentFurnitureRequest, callback func(response *SegmentFurnitureResponse, err error)) <-chan int

SegmentFurnitureWithCallback invokes the imageseg.SegmentFurniture API asynchronously

func (*Client) SegmentFurnitureWithChan 

func (client *Client) SegmentFurnitureWithChan(request *SegmentFurnitureRequest) (<-chan *SegmentFurnitureResponse, <-chan error)

SegmentFurnitureWithChan invokes the imageseg.SegmentFurniture API asynchronously

func (*Client) SegmentHDBody 

func (client *Client) SegmentHDBody(request *SegmentHDBodyRequest) (response *SegmentHDBodyResponse, err error)

SegmentHDBody invokes the imageseg.SegmentHDBody API synchronously

func (*Client) SegmentHDBodyWithCallback 

func (client *Client) SegmentHDBodyWithCallback(request *SegmentHDBodyRequest, callback func(response *SegmentHDBodyResponse, err error)) <-chan int

SegmentHDBodyWithCallback invokes the imageseg.SegmentHDBody API asynchronously

func (*Client) SegmentHDBodyWithChan 

func (client *Client) SegmentHDBodyWithChan(request *SegmentHDBodyRequest) (<-chan *SegmentHDBodyResponse, <-chan error)

SegmentHDBodyWithChan invokes the imageseg.SegmentHDBody API asynchronously

func (*Client) SegmentHDCommonImage added in v1.61.634 

func (client *Client) SegmentHDCommonImage(request *SegmentHDCommonImageRequest) (response *SegmentHDCommonImageResponse, err error)

SegmentHDCommonImage invokes the imageseg.SegmentHDCommonImage API synchronously

func (*Client) SegmentHDCommonImageWithCallback added in v1.61.634 

func (client *Client) SegmentHDCommonImageWithCallback(request *SegmentHDCommonImageRequest, callback func(response *SegmentHDCommonImageResponse, err error)) <-chan int

SegmentHDCommonImageWithCallback invokes the imageseg.SegmentHDCommonImage API asynchronously

func (*Client) SegmentHDCommonImageWithChan added in v1.61.634 

func (client *Client) SegmentHDCommonImageWithChan(request *SegmentHDCommonImageRequest) (<-chan *SegmentHDCommonImageResponse, <-chan error)

SegmentHDCommonImageWithChan invokes the imageseg.SegmentHDCommonImage API asynchronously

func (*Client) SegmentHDSky added in v1.61.634 

func (client *Client) SegmentHDSky(request *SegmentHDSkyRequest) (response *SegmentHDSkyResponse, err error)

SegmentHDSky invokes the imageseg.SegmentHDSky API synchronously

func (*Client) SegmentHDSkyWithCallback added in v1.61.634 

func (client *Client) SegmentHDSkyWithCallback(request *SegmentHDSkyRequest, callback func(response *SegmentHDSkyResponse, err error)) <-chan int

SegmentHDSkyWithCallback invokes the imageseg.SegmentHDSky API asynchronously

func (*Client) SegmentHDSkyWithChan added in v1.61.634 

func (client *Client) SegmentHDSkyWithChan(request *SegmentHDSkyRequest) (<-chan *SegmentHDSkyResponse, <-chan error)

SegmentHDSkyWithChan invokes the imageseg.SegmentHDSky API asynchronously

func (*Client) SegmentHair 

func (client *Client) SegmentHair(request *SegmentHairRequest) (response *SegmentHairResponse, err error)

SegmentHair invokes the imageseg.SegmentHair API synchronously

func (*Client) SegmentHairWithCallback 

func (client *Client) SegmentHairWithCallback(request *SegmentHairRequest, callback func(response *SegmentHairResponse, err error)) <-chan int

SegmentHairWithCallback invokes the imageseg.SegmentHair API asynchronously

func (*Client) SegmentHairWithChan 

func (client *Client) SegmentHairWithChan(request *SegmentHairRequest) (<-chan *SegmentHairResponse, <-chan error)

SegmentHairWithChan invokes the imageseg.SegmentHair API asynchronously

func (*Client) SegmentHead 

func (client *Client) SegmentHead(request *SegmentHeadRequest) (response *SegmentHeadResponse, err error)

SegmentHead invokes the imageseg.SegmentHead API synchronously

func (*Client) SegmentHeadWithCallback 

func (client *Client) SegmentHeadWithCallback(request *SegmentHeadRequest, callback func(response *SegmentHeadResponse, err error)) <-chan int

SegmentHeadWithCallback invokes the imageseg.SegmentHead API asynchronously

func (*Client) SegmentHeadWithChan 

func (client *Client) SegmentHeadWithChan(request *SegmentHeadRequest) (<-chan *SegmentHeadResponse, <-chan error)

SegmentHeadWithChan invokes the imageseg.SegmentHead API asynchronously 

func (client *Client) SegmentLogo(request *SegmentLogoRequest) (response *SegmentLogoResponse, err error)

SegmentLogo invokes the imageseg.SegmentLogo API synchronously

func (*Client) SegmentLogoWithCallback 

func (client *Client) SegmentLogoWithCallback(request *SegmentLogoRequest, callback func(response *SegmentLogoResponse, err error)) <-chan int

SegmentLogoWithCallback invokes the imageseg.SegmentLogo API asynchronously

func (*Client) SegmentLogoWithChan 

func (client *Client) SegmentLogoWithChan(request *SegmentLogoRequest) (<-chan *SegmentLogoResponse, <-chan error)

SegmentLogoWithChan invokes the imageseg.SegmentLogo API asynchronously

func (*Client) SegmentScene 

func (client *Client) SegmentScene(request *SegmentSceneRequest) (response *SegmentSceneResponse, err error)

SegmentScene invokes the imageseg.SegmentScene API synchronously

func (*Client) SegmentSceneWithCallback 

func (client *Client) SegmentSceneWithCallback(request *SegmentSceneRequest, callback func(response *SegmentSceneResponse, err error)) <-chan int

SegmentSceneWithCallback invokes the imageseg.SegmentScene API asynchronously

func (*Client) SegmentSceneWithChan 

func (client *Client) SegmentSceneWithChan(request *SegmentSceneRequest) (<-chan *SegmentSceneResponse, <-chan error)

SegmentSceneWithChan invokes the imageseg.SegmentScene API asynchronously

func (*Client) SegmentSkin added in v1.61.557 

func (client *Client) SegmentSkin(request *SegmentSkinRequest) (response *SegmentSkinResponse, err error)

SegmentSkin invokes the imageseg.SegmentSkin API synchronously

func (*Client) SegmentSkinWithCallback added in v1.61.557 

func (client *Client) SegmentSkinWithCallback(request *SegmentSkinRequest, callback func(response *SegmentSkinResponse, err error)) <-chan int

SegmentSkinWithCallback invokes the imageseg.SegmentSkin API asynchronously

func (*Client) SegmentSkinWithChan added in v1.61.557 

func (client *Client) SegmentSkinWithChan(request *SegmentSkinRequest) (<-chan *SegmentSkinResponse, <-chan error)

SegmentSkinWithChan invokes the imageseg.SegmentSkin API asynchronously

func (*Client) SegmentSky 

func (client *Client) SegmentSky(request *SegmentSkyRequest) (response *SegmentSkyResponse, err error)

SegmentSky invokes the imageseg.SegmentSky API synchronously

func (*Client) SegmentSkyWithCallback 

func (client *Client) SegmentSkyWithCallback(request *SegmentSkyRequest, callback func(response *SegmentSkyResponse, err error)) <-chan int

SegmentSkyWithCallback invokes the imageseg.SegmentSky API asynchronously

func (*Client) SegmentSkyWithChan 

func (client *Client) SegmentSkyWithChan(request *SegmentSkyRequest) (<-chan *SegmentSkyResponse, <-chan error)

SegmentSkyWithChan invokes the imageseg.SegmentSky API asynchronously

func (*Client) SegmentVehicle 

func (client *Client) SegmentVehicle(request *SegmentVehicleRequest) (response *SegmentVehicleResponse, err error)

SegmentVehicle invokes the imageseg.SegmentVehicle API synchronously

func (*Client) SegmentVehicleWithCallback 

func (client *Client) SegmentVehicleWithCallback(request *SegmentVehicleRequest, callback func(response *SegmentVehicleResponse, err error)) <-chan int

SegmentVehicleWithCallback invokes the imageseg.SegmentVehicle API asynchronously

func (*Client) SegmentVehicleWithChan 

func (client *Client) SegmentVehicleWithChan(request *SegmentVehicleRequest) (<-chan *SegmentVehicleResponse, <-chan error)

SegmentVehicleWithChan invokes the imageseg.SegmentVehicle API asynchronously

type Data 

type Data struct {
	JobId          string    `json:"JobId" xml:"JobId"`
	Result         string    `json:"Result" xml:"Result"`
	ErrorMessage   string    `json:"ErrorMessage" xml:"ErrorMessage"`
	URL            string    `json:"URL" xml:"URL"`
	ImageUrl       string    `json:"ImageUrl" xml:"ImageUrl"`
	ImageURL       string    `json:"ImageURL" xml:"ImageURL"`
	Status         string    `json:"Status" xml:"Status"`
	OriginImageURL string    `json:"OriginImageURL" xml:"OriginImageURL"`
	ErrorCode      string    `json:"ErrorCode" xml:"ErrorCode"`
	Elements       []Element `json:"Elements" xml:"Elements"`
}

Data is a nested struct in imageseg response

type Element 

type Element struct {
	Name           string `json:"Name" xml:"Name"`
	X              int    `json:"X" xml:"X"`
	ImageURL       string `json:"ImageURL" xml:"ImageURL"`
	Y              int    `json:"Y" xml:"Y"`
	Width          int    `json:"Width" xml:"Width"`
	Height         int    `json:"Height" xml:"Height"`
	OriginImageURL string `json:"OriginImageURL" xml:"OriginImageURL"`
}

Element is a nested struct in imageseg response

type ElementsInParseFace 

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

ElementsInParseFace is a nested struct in imageseg response

type ElementsInRefineMask 

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

ElementsInRefineMask is a nested struct in imageseg response

type ElementsInSegmentCloth 

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

ElementsInSegmentCloth is a nested struct in imageseg response

type ElementsInSegmentFace 

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

ElementsInSegmentFace is a nested struct in imageseg response

type ElementsInSegmentFurniture 

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

ElementsInSegmentFurniture is a nested struct in imageseg response

type ElementsInSegmentHair 

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

ElementsInSegmentHair is a nested struct in imageseg response

type ElementsInSegmentHead 

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

ElementsInSegmentHead is a nested struct in imageseg response

type ElementsInSegmentVehicle 

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

ElementsInSegmentVehicle is a nested struct in imageseg response

type GetAsyncJobResultRequest 

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

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 ParseFaceRequest 

type ParseFaceRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

ParseFaceRequest is the request struct for api ParseFace

func CreateParseFaceRequest 

func CreateParseFaceRequest() (request *ParseFaceRequest)

CreateParseFaceRequest creates a request to invoke ParseFace API

type ParseFaceResponse 

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

ParseFaceResponse is the response struct for api ParseFace

func CreateParseFaceResponse 

func CreateParseFaceResponse() (response *ParseFaceResponse)

CreateParseFaceResponse creates a response to parse from ParseFace response

type RefineMaskRequest 

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

RefineMaskRequest is the request struct for api RefineMask

func CreateRefineMaskRequest 

func CreateRefineMaskRequest() (request *RefineMaskRequest)

CreateRefineMaskRequest creates a request to invoke RefineMask API

type RefineMaskResponse 

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

RefineMaskResponse is the response struct for api RefineMask

func CreateRefineMaskResponse 

func CreateRefineMaskResponse() (response *RefineMaskResponse)

CreateRefineMaskResponse creates a response to parse from RefineMask response

type SegmentAnimalRequest 

type SegmentAnimalRequest struct {
	*requests.RpcRequest
	ReturnForm string `position:"Query" name:"ReturnForm"`
	ImageURL   string `position:"Query" name:"ImageURL"`
}

SegmentAnimalRequest is the request struct for api SegmentAnimal

func CreateSegmentAnimalRequest 

func CreateSegmentAnimalRequest() (request *SegmentAnimalRequest)

CreateSegmentAnimalRequest creates a request to invoke SegmentAnimal API

type SegmentAnimalResponse 

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

SegmentAnimalResponse is the response struct for api SegmentAnimal

func CreateSegmentAnimalResponse 

func CreateSegmentAnimalResponse() (response *SegmentAnimalResponse)

CreateSegmentAnimalResponse creates a response to parse from SegmentAnimal response

type SegmentBodyRequest 

type SegmentBodyRequest struct {
	*requests.RpcRequest
	ReturnForm string           `position:"Query" name:"ReturnForm"`
	Async      requests.Boolean `position:"Body" name:"Async"`
	ImageURL   string           `position:"Query" name:"ImageURL"`
}

SegmentBodyRequest is the request struct for api SegmentBody

func CreateSegmentBodyRequest 

func CreateSegmentBodyRequest() (request *SegmentBodyRequest)

CreateSegmentBodyRequest creates a request to invoke SegmentBody API

type SegmentBodyResponse 

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

SegmentBodyResponse is the response struct for api SegmentBody

func CreateSegmentBodyResponse 

func CreateSegmentBodyResponse() (response *SegmentBodyResponse)

CreateSegmentBodyResponse creates a response to parse from SegmentBody response

type SegmentClothRequest 

type SegmentClothRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentClothRequest is the request struct for api SegmentCloth

func CreateSegmentClothRequest 

func CreateSegmentClothRequest() (request *SegmentClothRequest)

CreateSegmentClothRequest creates a request to invoke SegmentCloth API

type SegmentClothResponse 

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

SegmentClothResponse is the response struct for api SegmentCloth

func CreateSegmentClothResponse 

func CreateSegmentClothResponse() (response *SegmentClothResponse)

CreateSegmentClothResponse creates a response to parse from SegmentCloth response

type SegmentCommodityRequest 

type SegmentCommodityRequest struct {
	*requests.RpcRequest
	ReturnForm string `position:"Query" name:"ReturnForm"`
	ImageURL   string `position:"Query" name:"ImageURL"`
}

SegmentCommodityRequest is the request struct for api SegmentCommodity

func CreateSegmentCommodityRequest 

func CreateSegmentCommodityRequest() (request *SegmentCommodityRequest)

CreateSegmentCommodityRequest creates a request to invoke SegmentCommodity API

type SegmentCommodityResponse 

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

SegmentCommodityResponse is the response struct for api SegmentCommodity

func CreateSegmentCommodityResponse 

func CreateSegmentCommodityResponse() (response *SegmentCommodityResponse)

CreateSegmentCommodityResponse creates a response to parse from SegmentCommodity response

type SegmentCommonImageRequest 

type SegmentCommonImageRequest struct {
	*requests.RpcRequest
	ReturnForm string `position:"Query" name:"ReturnForm"`
	ImageURL   string `position:"Query" name:"ImageURL"`
}

SegmentCommonImageRequest is the request struct for api SegmentCommonImage

func CreateSegmentCommonImageRequest 

func CreateSegmentCommonImageRequest() (request *SegmentCommonImageRequest)

CreateSegmentCommonImageRequest creates a request to invoke SegmentCommonImage API

type SegmentCommonImageResponse 

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

SegmentCommonImageResponse is the response struct for api SegmentCommonImage

func CreateSegmentCommonImageResponse 

func CreateSegmentCommonImageResponse() (response *SegmentCommonImageResponse)

CreateSegmentCommonImageResponse creates a response to parse from SegmentCommonImage response

type SegmentFaceRequest 

type SegmentFaceRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentFaceRequest is the request struct for api SegmentFace

func CreateSegmentFaceRequest 

func CreateSegmentFaceRequest() (request *SegmentFaceRequest)

CreateSegmentFaceRequest creates a request to invoke SegmentFace API

type SegmentFaceResponse 

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

SegmentFaceResponse is the response struct for api SegmentFace

func CreateSegmentFaceResponse 

func CreateSegmentFaceResponse() (response *SegmentFaceResponse)

CreateSegmentFaceResponse creates a response to parse from SegmentFace response

type SegmentFoodRequest 

type SegmentFoodRequest struct {
	*requests.RpcRequest
	ReturnForm string `position:"Query" name:"ReturnForm"`
	ImageURL   string `position:"Query" name:"ImageURL"`
}

SegmentFoodRequest is the request struct for api SegmentFood

func CreateSegmentFoodRequest 

func CreateSegmentFoodRequest() (request *SegmentFoodRequest)

CreateSegmentFoodRequest creates a request to invoke SegmentFood API

type SegmentFoodResponse 

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

SegmentFoodResponse is the response struct for api SegmentFood

func CreateSegmentFoodResponse 

func CreateSegmentFoodResponse() (response *SegmentFoodResponse)

CreateSegmentFoodResponse creates a response to parse from SegmentFood response

type SegmentFurnitureRequest 

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

SegmentFurnitureRequest is the request struct for api SegmentFurniture

func CreateSegmentFurnitureRequest 

func CreateSegmentFurnitureRequest() (request *SegmentFurnitureRequest)

CreateSegmentFurnitureRequest creates a request to invoke SegmentFurniture API

type SegmentFurnitureResponse 

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

SegmentFurnitureResponse is the response struct for api SegmentFurniture

func CreateSegmentFurnitureResponse 

func CreateSegmentFurnitureResponse() (response *SegmentFurnitureResponse)

CreateSegmentFurnitureResponse creates a response to parse from SegmentFurniture response

type SegmentHDBodyRequest 

type SegmentHDBodyRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentHDBodyRequest is the request struct for api SegmentHDBody

func CreateSegmentHDBodyRequest 

func CreateSegmentHDBodyRequest() (request *SegmentHDBodyRequest)

CreateSegmentHDBodyRequest creates a request to invoke SegmentHDBody API

type SegmentHDBodyResponse 

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

SegmentHDBodyResponse is the response struct for api SegmentHDBody

func CreateSegmentHDBodyResponse 

func CreateSegmentHDBodyResponse() (response *SegmentHDBodyResponse)

CreateSegmentHDBodyResponse creates a response to parse from SegmentHDBody response

type SegmentHDCommonImageRequest added in v1.61.634 

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

SegmentHDCommonImageRequest is the request struct for api SegmentHDCommonImage

func CreateSegmentHDCommonImageRequest added in v1.61.634 

func CreateSegmentHDCommonImageRequest() (request *SegmentHDCommonImageRequest)

CreateSegmentHDCommonImageRequest creates a request to invoke SegmentHDCommonImage API

type SegmentHDCommonImageResponse added in v1.61.634 

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

SegmentHDCommonImageResponse is the response struct for api SegmentHDCommonImage

func CreateSegmentHDCommonImageResponse added in v1.61.634 

func CreateSegmentHDCommonImageResponse() (response *SegmentHDCommonImageResponse)

CreateSegmentHDCommonImageResponse creates a response to parse from SegmentHDCommonImage response

type SegmentHDSkyRequest added in v1.61.634 

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

SegmentHDSkyRequest is the request struct for api SegmentHDSky

func CreateSegmentHDSkyRequest added in v1.61.634 

func CreateSegmentHDSkyRequest() (request *SegmentHDSkyRequest)

CreateSegmentHDSkyRequest creates a request to invoke SegmentHDSky API

type SegmentHDSkyResponse added in v1.61.634 

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

SegmentHDSkyResponse is the response struct for api SegmentHDSky

func CreateSegmentHDSkyResponse added in v1.61.634 

func CreateSegmentHDSkyResponse() (response *SegmentHDSkyResponse)

CreateSegmentHDSkyResponse creates a response to parse from SegmentHDSky response

type SegmentHairRequest 

type SegmentHairRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentHairRequest is the request struct for api SegmentHair

func CreateSegmentHairRequest 

func CreateSegmentHairRequest() (request *SegmentHairRequest)

CreateSegmentHairRequest creates a request to invoke SegmentHair API

type SegmentHairResponse 

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

SegmentHairResponse is the response struct for api SegmentHair

func CreateSegmentHairResponse 

func CreateSegmentHairResponse() (response *SegmentHairResponse)

CreateSegmentHairResponse creates a response to parse from SegmentHair response

type SegmentHeadRequest 

type SegmentHeadRequest struct {
	*requests.RpcRequest
	ReturnForm string `position:"Query" name:"ReturnForm"`
	ImageURL   string `position:"Query" name:"ImageURL"`
}

SegmentHeadRequest is the request struct for api SegmentHead

func CreateSegmentHeadRequest 

func CreateSegmentHeadRequest() (request *SegmentHeadRequest)

CreateSegmentHeadRequest creates a request to invoke SegmentHead API

type SegmentHeadResponse 

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

SegmentHeadResponse is the response struct for api SegmentHead

func CreateSegmentHeadResponse 

func CreateSegmentHeadResponse() (response *SegmentHeadResponse)

CreateSegmentHeadResponse creates a response to parse from SegmentHead response

type SegmentLogoRequest 

type SegmentLogoRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentLogoRequest is the request struct for api SegmentLogo

func CreateSegmentLogoRequest 

func CreateSegmentLogoRequest() (request *SegmentLogoRequest)

CreateSegmentLogoRequest creates a request to invoke SegmentLogo API

type SegmentLogoResponse 

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

SegmentLogoResponse is the response struct for api SegmentLogo

func CreateSegmentLogoResponse 

func CreateSegmentLogoResponse() (response *SegmentLogoResponse)

CreateSegmentLogoResponse creates a response to parse from SegmentLogo response

type SegmentSceneRequest 

type SegmentSceneRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentSceneRequest is the request struct for api SegmentScene

func CreateSegmentSceneRequest 

func CreateSegmentSceneRequest() (request *SegmentSceneRequest)

CreateSegmentSceneRequest creates a request to invoke SegmentScene API

type SegmentSceneResponse 

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

SegmentSceneResponse is the response struct for api SegmentScene

func CreateSegmentSceneResponse 

func CreateSegmentSceneResponse() (response *SegmentSceneResponse)

CreateSegmentSceneResponse creates a response to parse from SegmentScene response

type SegmentSkinRequest added in v1.61.557 

type SegmentSkinRequest struct {
	*requests.RpcRequest
	URL string `position:"Body" name:"URL"`
}

SegmentSkinRequest is the request struct for api SegmentSkin

func CreateSegmentSkinRequest added in v1.61.557 

func CreateSegmentSkinRequest() (request *SegmentSkinRequest)

CreateSegmentSkinRequest creates a request to invoke SegmentSkin API

type SegmentSkinResponse added in v1.61.557 

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

SegmentSkinResponse is the response struct for api SegmentSkin

func CreateSegmentSkinResponse added in v1.61.557 

func CreateSegmentSkinResponse() (response *SegmentSkinResponse)

CreateSegmentSkinResponse creates a response to parse from SegmentSkin response

type SegmentSkyRequest 

type SegmentSkyRequest struct {
	*requests.RpcRequest
	ImageURL string `position:"Query" name:"ImageURL"`
}

SegmentSkyRequest is the request struct for api SegmentSky

func CreateSegmentSkyRequest 

func CreateSegmentSkyRequest() (request *SegmentSkyRequest)

CreateSegmentSkyRequest creates a request to invoke SegmentSky API

type SegmentSkyResponse 

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

SegmentSkyResponse is the response struct for api SegmentSky

func CreateSegmentSkyResponse 

func CreateSegmentSkyResponse() (response *SegmentSkyResponse)

CreateSegmentSkyResponse creates a response to parse from SegmentSky response

type SegmentVehicleRequest 

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

SegmentVehicleRequest is the request struct for api SegmentVehicle

func CreateSegmentVehicleRequest 

func CreateSegmentVehicleRequest() (request *SegmentVehicleRequest)

CreateSegmentVehicleRequest creates a request to invoke SegmentVehicle API

type SegmentVehicleResponse 

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

SegmentVehicleResponse is the response struct for api SegmentVehicle

func CreateSegmentVehicleResponse 

func CreateSegmentVehicleResponse() (response *SegmentVehicleResponse)

CreateSegmentVehicleResponse creates a response to parse from SegmentVehicle 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.