facebody

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 AddFaceEntityRequest 

type AddFaceEntityRequest struct {
	*requests.RpcRequest
	EntityId           string           `position:"Body" name:"EntityId"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Labels             string           `position:"Body" name:"Labels"`
	DbName             string           `position:"Body" name:"DbName"`
}

AddFaceEntityRequest is the request struct for api AddFaceEntity

func CreateAddFaceEntityRequest 

func CreateAddFaceEntityRequest() (request *AddFaceEntityRequest)

CreateAddFaceEntityRequest creates a request to invoke AddFaceEntity API

type AddFaceEntityResponse 

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

AddFaceEntityResponse is the response struct for api AddFaceEntity

func CreateAddFaceEntityResponse 

func CreateAddFaceEntityResponse() (response *AddFaceEntityResponse)

CreateAddFaceEntityResponse creates a response to parse from AddFaceEntity response

type AddFaceImageTemplateRequest 

type AddFaceImageTemplateRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	UserId             string           `position:"Body" name:"UserId"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

AddFaceImageTemplateRequest is the request struct for api AddFaceImageTemplate

func CreateAddFaceImageTemplateRequest 

func CreateAddFaceImageTemplateRequest() (request *AddFaceImageTemplateRequest)

CreateAddFaceImageTemplateRequest creates a request to invoke AddFaceImageTemplate API

type AddFaceImageTemplateResponse 

type AddFaceImageTemplateResponse 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"`
}

AddFaceImageTemplateResponse is the response struct for api AddFaceImageTemplate

func CreateAddFaceImageTemplateResponse 

func CreateAddFaceImageTemplateResponse() (response *AddFaceImageTemplateResponse)

CreateAddFaceImageTemplateResponse creates a response to parse from AddFaceImageTemplate response

type AddFaceRequest 

type AddFaceRequest struct {
	*requests.RpcRequest
	EntityId                              string           `position:"Body" name:"EntityId"`
	FormatResultToJson                    requests.Boolean `position:"Query" name:"FormatResultToJson"`
	QualityScoreThreshold                 requests.Float   `position:"Body" name:"QualityScoreThreshold"`
	SimilarityScoreThresholdBetweenEntity requests.Float   `position:"Body" name:"SimilarityScoreThresholdBetweenEntity"`
	ExtraData                             string           `position:"Body" name:"ExtraData"`
	OssFile                               string           `position:"Query" name:"OssFile"`
	SimilarityScoreThresholdInEntity      requests.Float   `position:"Body" name:"SimilarityScoreThresholdInEntity"`
	RequestProxyBy                        string           `position:"Query" name:"RequestProxyBy"`
	DbName                                string           `position:"Body" name:"DbName"`
	ImageUrl                              string           `position:"Body" name:"ImageUrl"`
}

AddFaceRequest is the request struct for api AddFace

func CreateAddFaceRequest 

func CreateAddFaceRequest() (request *AddFaceRequest)

CreateAddFaceRequest creates a request to invoke AddFace API

type AddFaceResponse 

type AddFaceResponse 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"`
}

AddFaceResponse is the response struct for api AddFace

func CreateAddFaceResponse 

func CreateAddFaceResponse() (response *AddFaceResponse)

CreateAddFaceResponse creates a response to parse from AddFace response

type Age 

type Age struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Age is a nested struct in facebody response

type AgeList 

type AgeList struct {
	Age []int `json:"Age" xml:"Age"`
}

AgeList is a nested struct in facebody response

type Attributes 

type Attributes struct {
	AttributesItem []AttributesItem `json:"Attributes" xml:"Attributes"`
}

Attributes is a nested struct in facebody response

type AttributesItem 

type AttributesItem struct {
	Gender      Gender      `json:"Gender" xml:"Gender"`
	Orient      Orient      `json:"Orient" xml:"Orient"`
	Age         Age         `json:"Age" xml:"Age"`
	UpperWear   UpperWear   `json:"UpperWear" xml:"UpperWear"`
	Glasses     Glasses     `json:"Glasses" xml:"Glasses"`
	LowerWear   LowerWear   `json:"LowerWear" xml:"LowerWear"`
	LowerColor  LowerColor  `json:"LowerColor" xml:"LowerColor"`
	Hat         Hat         `json:"Hat" xml:"Hat"`
	Handbag     Handbag     `json:"Handbag" xml:"Handbag"`
	Backpack    Backpack    `json:"Backpack" xml:"Backpack"`
	UpperColor  UpperColor  `json:"UpperColor" xml:"UpperColor"`
	ShoulderBag ShoulderBag `json:"ShoulderBag" xml:"ShoulderBag"`
}

AttributesItem is a nested struct in facebody response

type Backpack 

type Backpack struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Backpack is a nested struct in facebody response

type BatchAddFacesFaces 

type BatchAddFacesFaces struct {
	ExtraData string `name:"ExtraData"`
	ImageURL  string `name:"ImageURL"`
}

BatchAddFacesFaces is a repeated param struct in BatchAddFacesRequest

type BatchAddFacesRequest 

type BatchAddFacesRequest struct {
	*requests.RpcRequest
	EntityId                              string                `position:"Body" name:"EntityId"`
	FormatResultToJson                    requests.Boolean      `position:"Query" name:"FormatResultToJson"`
	QualityScoreThreshold                 requests.Float        `position:"Body" name:"QualityScoreThreshold"`
	SimilarityScoreThresholdBetweenEntity requests.Float        `position:"Body" name:"SimilarityScoreThresholdBetweenEntity"`
	OssFile                               string                `position:"Query" name:"OssFile"`
	SimilarityScoreThresholdInEntity      requests.Float        `position:"Body" name:"SimilarityScoreThresholdInEntity"`
	RequestProxyBy                        string                `position:"Query" name:"RequestProxyBy"`
	DbName                                string                `position:"Body" name:"DbName"`
	Faces                                 *[]BatchAddFacesFaces `position:"Body" name:"Faces"  type:"Json"`
}

BatchAddFacesRequest is the request struct for api BatchAddFaces

func CreateBatchAddFacesRequest 

func CreateBatchAddFacesRequest() (request *BatchAddFacesRequest)

CreateBatchAddFacesRequest creates a request to invoke BatchAddFaces API

type BatchAddFacesResponse 

type BatchAddFacesResponse 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"`
}

BatchAddFacesResponse is the response struct for api BatchAddFaces

func CreateBatchAddFacesResponse 

func CreateBatchAddFacesResponse() (response *BatchAddFacesResponse)

CreateBatchAddFacesResponse creates a response to parse from BatchAddFaces response

type BeautifyBodyAgeRange 

type BeautifyBodyAgeRange struct {
	AgeMax     string `name:"AgeMax"`
	AgeMinimum string `name:"AgeMinimum"`
}

BeautifyBodyAgeRange is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyBodyBoxes 

type BeautifyBodyBodyBoxes struct {
	X      string `name:"X"`
	Width  string `name:"Width"`
	Y      string `name:"Y"`
	Height string `name:"Height"`
}

BeautifyBodyBodyBoxes is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyFaceList 

type BeautifyBodyFaceList struct {
	Gender  string                      `name:"Gender"`
	FaceBox BeautifyBodyFaceListFaceBox `name:"FaceBox" type:"Struct"`
	Age     string                      `name:"Age"`
}

BeautifyBodyFaceList is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyFaceListFaceBox 

type BeautifyBodyFaceListFaceBox struct {
	X      string `name:"X"`
	Width  string `name:"Width"`
	Y      string `name:"Y"`
	Height string `name:"Height"`
}

BeautifyBodyFaceListFaceBox is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyPoseList 

type BeautifyBodyPoseList struct {
	Pose *[]BeautifyBodyPoseListPoseItem `name:"Pose" type:"Repeated"`
}

BeautifyBodyPoseList is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyPoseListPoseItem 

type BeautifyBodyPoseListPoseItem struct {
	Score string `name:"Score"`
	X     string `name:"X"`
	Y     string `name:"Y"`
}

BeautifyBodyPoseListPoseItem is a repeated param struct in BeautifyBodyRequest

type BeautifyBodyRequest 

type BeautifyBodyRequest struct {
	*requests.RpcRequest
	BodyBoxes           *[]BeautifyBodyBodyBoxes `position:"Body" name:"BodyBoxes"  type:"Json"`
	LengthenDegree      requests.Float           `position:"Body" name:"LengthenDegree"`
	MaleLiquifyDegree   requests.Float           `position:"Body" name:"MaleLiquifyDegree"`
	FormatResultToJson  requests.Boolean         `position:"Query" name:"FormatResultToJson"`
	OriginalWidth       requests.Integer         `position:"Body" name:"OriginalWidth"`
	IsPregnant          requests.Boolean         `position:"Body" name:"IsPregnant"`
	FaceList            *[]BeautifyBodyFaceList  `position:"Body" name:"FaceList"  type:"Json"`
	OssFile             string                   `position:"Query" name:"OssFile"`
	AgeRange            BeautifyBodyAgeRange     `position:"Body" name:"AgeRange"  type:"Struct"`
	Custom              requests.Integer         `position:"Body" name:"Custom"`
	RequestProxyBy      string                   `position:"Query" name:"RequestProxyBy"`
	OriginalHeight      requests.Integer         `position:"Body" name:"OriginalHeight"`
	ImageURL            string                   `position:"Body" name:"ImageURL"`
	FemaleLiquifyDegree requests.Float           `position:"Body" name:"FemaleLiquifyDegree"`
	PoseList            *[]BeautifyBodyPoseList  `position:"Body" name:"PoseList"  type:"Json"`
}

BeautifyBodyRequest is the request struct for api BeautifyBody

func CreateBeautifyBodyRequest 

func CreateBeautifyBodyRequest() (request *BeautifyBodyRequest)

CreateBeautifyBodyRequest creates a request to invoke BeautifyBody API

type BeautifyBodyResponse 

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

BeautifyBodyResponse is the response struct for api BeautifyBody

func CreateBeautifyBodyResponse 

func CreateBeautifyBodyResponse() (response *BeautifyBodyResponse)

CreateBeautifyBodyResponse creates a response to parse from BeautifyBody response

type BeautyList 

type BeautyList struct {
	Beauty []float64 `json:"Beauty" xml:"Beauty"`
}

BeautyList is a nested struct in facebody response

type BlurFaceRequest 

type BlurFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

BlurFaceRequest is the request struct for api BlurFace

func CreateBlurFaceRequest 

func CreateBlurFaceRequest() (request *BlurFaceRequest)

CreateBlurFaceRequest creates a request to invoke BlurFace API

type BlurFaceResponse 

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

BlurFaceResponse is the response struct for api BlurFace

func CreateBlurFaceResponse 

func CreateBlurFaceResponse() (response *BlurFaceResponse)

CreateBlurFaceResponse creates a response to parse from BlurFace response

type BlurListInDetectFace 

type BlurListInDetectFace struct {
	Blur []float64 `json:"Blur" xml:"Blur"`
}

BlurListInDetectFace is a nested struct in facebody response

type BlurListInRecognizeFace 

type BlurListInRecognizeFace struct {
	Blur []float64 `json:"Blur" xml:"Blur"`
}

BlurListInRecognizeFace is a nested struct in facebody response

type Bodies 

type Bodies struct {
	Body []Body `json:"Body" xml:"Body"`
}

Bodies is a nested struct in facebody response

type Body 

type Body struct {
	Confident float64    `json:"Confident" xml:"Confident"`
	Label     string     `json:"Label" xml:"Label"`
	Positions []Position `json:"Positions" xml:"Positions"`
}

Body is a nested struct in facebody response

type BodyPostureRequest 

type BodyPostureRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

BodyPostureRequest is the request struct for api BodyPosture

func CreateBodyPostureRequest 

func CreateBodyPostureRequest() (request *BodyPostureRequest)

CreateBodyPostureRequest creates a request to invoke BodyPosture API

type BodyPostureResponse 

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

BodyPostureResponse is the response struct for api BodyPosture

func CreateBodyPostureResponse 

func CreateBodyPostureResponse() (response *BodyPostureResponse)

CreateBodyPostureResponse creates a response to parse from BodyPosture response

type Box 

type Box struct {
	Confident float64    `json:"Confident" xml:"Confident"`
	Left      int64      `json:"Left" xml:"Left"`
	Right     int64      `json:"Right" xml:"Right"`
	Top       int64      `json:"Top" xml:"Top"`
	Bottom    int64      `json:"Bottom" xml:"Bottom"`
	Positions []Position `json:"Positions" xml:"Positions"`
}

Box is a nested struct in facebody response

type BoxInDetectChefCap 

type BoxInDetectChefCap struct {
	Box []float64 `json:"Box" xml:"Box"`
}

BoxInDetectChefCap is a nested struct in facebody response

type BoxInRecognizeAction 

type BoxInRecognizeAction struct {
	Box []int `json:"Box" xml:"Box"`
}

BoxInRecognizeAction is a nested struct in facebody response

type BoxesInDetectIPCPedestrian 

type BoxesInDetectIPCPedestrian struct {
	Box []int `json:"Box" xml:"Box"`
}

BoxesInDetectIPCPedestrian is a nested struct in facebody response

type BoxesInDetectPedestrian 

type BoxesInDetectPedestrian struct {
	Box []int `json:"Box" xml:"Box"`
}

BoxesInDetectPedestrian is a nested struct in facebody response

type BoxesInPedestrianDetectAttribute 

type BoxesInPedestrianDetectAttribute struct {
	BoxesItem []BoxesItem `json:"Boxes" xml:"Boxes"`
}

BoxesInPedestrianDetectAttribute is a nested struct in facebody response

type BoxesInRecognizeAction 

type BoxesInRecognizeAction struct {
	BoxesItem []BoxesItem `json:"Boxes" xml:"Boxes"`
}

BoxesInRecognizeAction is a nested struct in facebody response

type BoxesItem 

type BoxesItem struct {
	TopLeftX     float64 `json:"TopLeftX" xml:"TopLeftX"`
	TopLeftY     float64 `json:"TopLeftY" xml:"TopLeftY"`
	Score        float64 `json:"Score" xml:"Score"`
	BottomRightX float64 `json:"BottomRightX" xml:"BottomRightX"`
	BottomRightY float64 `json:"BottomRightY" xml:"BottomRightY"`
	Box          []int   `json:"Box" xml:"Box"`
}

BoxesItem is a nested struct in facebody response

type CellPhone 

type CellPhone struct {
	Score     float64 `json:"Score" xml:"Score"`
	Threshold float64 `json:"Threshold" xml:"Threshold"`
}

CellPhone is a nested struct in facebody 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) AddFace 

func (client *Client) AddFace(request *AddFaceRequest) (response *AddFaceResponse, err error)

AddFace invokes the facebody.AddFace API synchronously

func (*Client) AddFaceEntity 

func (client *Client) AddFaceEntity(request *AddFaceEntityRequest) (response *AddFaceEntityResponse, err error)

AddFaceEntity invokes the facebody.AddFaceEntity API synchronously

func (*Client) AddFaceEntityWithCallback 

func (client *Client) AddFaceEntityWithCallback(request *AddFaceEntityRequest, callback func(response *AddFaceEntityResponse, err error)) <-chan int

AddFaceEntityWithCallback invokes the facebody.AddFaceEntity API asynchronously

func (*Client) AddFaceEntityWithChan 

func (client *Client) AddFaceEntityWithChan(request *AddFaceEntityRequest) (<-chan *AddFaceEntityResponse, <-chan error)

AddFaceEntityWithChan invokes the facebody.AddFaceEntity API asynchronously

func (*Client) AddFaceImageTemplate 

func (client *Client) AddFaceImageTemplate(request *AddFaceImageTemplateRequest) (response *AddFaceImageTemplateResponse, err error)

AddFaceImageTemplate invokes the facebody.AddFaceImageTemplate API synchronously

func (*Client) AddFaceImageTemplateWithCallback 

func (client *Client) AddFaceImageTemplateWithCallback(request *AddFaceImageTemplateRequest, callback func(response *AddFaceImageTemplateResponse, err error)) <-chan int

AddFaceImageTemplateWithCallback invokes the facebody.AddFaceImageTemplate API asynchronously

func (*Client) AddFaceImageTemplateWithChan 

func (client *Client) AddFaceImageTemplateWithChan(request *AddFaceImageTemplateRequest) (<-chan *AddFaceImageTemplateResponse, <-chan error)

AddFaceImageTemplateWithChan invokes the facebody.AddFaceImageTemplate API asynchronously

func (*Client) AddFaceWithCallback 

func (client *Client) AddFaceWithCallback(request *AddFaceRequest, callback func(response *AddFaceResponse, err error)) <-chan int

AddFaceWithCallback invokes the facebody.AddFace API asynchronously

func (*Client) AddFaceWithChan 

func (client *Client) AddFaceWithChan(request *AddFaceRequest) (<-chan *AddFaceResponse, <-chan error)

AddFaceWithChan invokes the facebody.AddFace API asynchronously

func (*Client) BatchAddFaces 

func (client *Client) BatchAddFaces(request *BatchAddFacesRequest) (response *BatchAddFacesResponse, err error)

BatchAddFaces invokes the facebody.BatchAddFaces API synchronously

func (*Client) BatchAddFacesWithCallback 

func (client *Client) BatchAddFacesWithCallback(request *BatchAddFacesRequest, callback func(response *BatchAddFacesResponse, err error)) <-chan int

BatchAddFacesWithCallback invokes the facebody.BatchAddFaces API asynchronously

func (*Client) BatchAddFacesWithChan 

func (client *Client) BatchAddFacesWithChan(request *BatchAddFacesRequest) (<-chan *BatchAddFacesResponse, <-chan error)

BatchAddFacesWithChan invokes the facebody.BatchAddFaces API asynchronously

func (*Client) BeautifyBody 

func (client *Client) BeautifyBody(request *BeautifyBodyRequest) (response *BeautifyBodyResponse, err error)

BeautifyBody invokes the facebody.BeautifyBody API synchronously

func (*Client) BeautifyBodyWithCallback 

func (client *Client) BeautifyBodyWithCallback(request *BeautifyBodyRequest, callback func(response *BeautifyBodyResponse, err error)) <-chan int

BeautifyBodyWithCallback invokes the facebody.BeautifyBody API asynchronously

func (*Client) BeautifyBodyWithChan 

func (client *Client) BeautifyBodyWithChan(request *BeautifyBodyRequest) (<-chan *BeautifyBodyResponse, <-chan error)

BeautifyBodyWithChan invokes the facebody.BeautifyBody API asynchronously

func (*Client) BlurFace 

func (client *Client) BlurFace(request *BlurFaceRequest) (response *BlurFaceResponse, err error)

BlurFace invokes the facebody.BlurFace API synchronously

func (*Client) BlurFaceWithCallback 

func (client *Client) BlurFaceWithCallback(request *BlurFaceRequest, callback func(response *BlurFaceResponse, err error)) <-chan int

BlurFaceWithCallback invokes the facebody.BlurFace API asynchronously

func (*Client) BlurFaceWithChan 

func (client *Client) BlurFaceWithChan(request *BlurFaceRequest) (<-chan *BlurFaceResponse, <-chan error)

BlurFaceWithChan invokes the facebody.BlurFace API asynchronously

func (*Client) BodyPosture 

func (client *Client) BodyPosture(request *BodyPostureRequest) (response *BodyPostureResponse, err error)

BodyPosture invokes the facebody.BodyPosture API synchronously

func (*Client) BodyPostureWithCallback 

func (client *Client) BodyPostureWithCallback(request *BodyPostureRequest, callback func(response *BodyPostureResponse, err error)) <-chan int

BodyPostureWithCallback invokes the facebody.BodyPosture API asynchronously

func (*Client) BodyPostureWithChan 

func (client *Client) BodyPostureWithChan(request *BodyPostureRequest) (<-chan *BodyPostureResponse, <-chan error)

BodyPostureWithChan invokes the facebody.BodyPosture API asynchronously

func (*Client) CompareFace 

func (client *Client) CompareFace(request *CompareFaceRequest) (response *CompareFaceResponse, err error)

CompareFace invokes the facebody.CompareFace API synchronously

func (*Client) CompareFaceWithCallback 

func (client *Client) CompareFaceWithCallback(request *CompareFaceRequest, callback func(response *CompareFaceResponse, err error)) <-chan int

CompareFaceWithCallback invokes the facebody.CompareFace API asynchronously

func (*Client) CompareFaceWithChan 

func (client *Client) CompareFaceWithChan(request *CompareFaceRequest) (<-chan *CompareFaceResponse, <-chan error)

CompareFaceWithChan invokes the facebody.CompareFace API asynchronously

func (*Client) CountCrowd 

func (client *Client) CountCrowd(request *CountCrowdRequest) (response *CountCrowdResponse, err error)

CountCrowd invokes the facebody.CountCrowd API synchronously

func (*Client) CountCrowdWithCallback 

func (client *Client) CountCrowdWithCallback(request *CountCrowdRequest, callback func(response *CountCrowdResponse, err error)) <-chan int

CountCrowdWithCallback invokes the facebody.CountCrowd API asynchronously

func (*Client) CountCrowdWithChan 

func (client *Client) CountCrowdWithChan(request *CountCrowdRequest) (<-chan *CountCrowdResponse, <-chan error)

CountCrowdWithChan invokes the facebody.CountCrowd API asynchronously

func (*Client) CreateFaceDb 

func (client *Client) CreateFaceDb(request *CreateFaceDbRequest) (response *CreateFaceDbResponse, err error)

CreateFaceDb invokes the facebody.CreateFaceDb API synchronously

func (*Client) CreateFaceDbWithCallback 

func (client *Client) CreateFaceDbWithCallback(request *CreateFaceDbRequest, callback func(response *CreateFaceDbResponse, err error)) <-chan int

CreateFaceDbWithCallback invokes the facebody.CreateFaceDb API asynchronously

func (*Client) CreateFaceDbWithChan 

func (client *Client) CreateFaceDbWithChan(request *CreateFaceDbRequest) (<-chan *CreateFaceDbResponse, <-chan error)

CreateFaceDbWithChan invokes the facebody.CreateFaceDb API asynchronously

func (*Client) DeleteFace 

func (client *Client) DeleteFace(request *DeleteFaceRequest) (response *DeleteFaceResponse, err error)

DeleteFace invokes the facebody.DeleteFace API synchronously

func (*Client) DeleteFaceDb 

func (client *Client) DeleteFaceDb(request *DeleteFaceDbRequest) (response *DeleteFaceDbResponse, err error)

DeleteFaceDb invokes the facebody.DeleteFaceDb API synchronously

func (*Client) DeleteFaceDbWithCallback 

func (client *Client) DeleteFaceDbWithCallback(request *DeleteFaceDbRequest, callback func(response *DeleteFaceDbResponse, err error)) <-chan int

DeleteFaceDbWithCallback invokes the facebody.DeleteFaceDb API asynchronously

func (*Client) DeleteFaceDbWithChan 

func (client *Client) DeleteFaceDbWithChan(request *DeleteFaceDbRequest) (<-chan *DeleteFaceDbResponse, <-chan error)

DeleteFaceDbWithChan invokes the facebody.DeleteFaceDb API asynchronously

func (*Client) DeleteFaceEntity 

func (client *Client) DeleteFaceEntity(request *DeleteFaceEntityRequest) (response *DeleteFaceEntityResponse, err error)

DeleteFaceEntity invokes the facebody.DeleteFaceEntity API synchronously

func (*Client) DeleteFaceEntityWithCallback 

func (client *Client) DeleteFaceEntityWithCallback(request *DeleteFaceEntityRequest, callback func(response *DeleteFaceEntityResponse, err error)) <-chan int

DeleteFaceEntityWithCallback invokes the facebody.DeleteFaceEntity API asynchronously

func (*Client) DeleteFaceEntityWithChan 

func (client *Client) DeleteFaceEntityWithChan(request *DeleteFaceEntityRequest) (<-chan *DeleteFaceEntityResponse, <-chan error)

DeleteFaceEntityWithChan invokes the facebody.DeleteFaceEntity API asynchronously

func (*Client) DeleteFaceImageTemplate 

func (client *Client) DeleteFaceImageTemplate(request *DeleteFaceImageTemplateRequest) (response *DeleteFaceImageTemplateResponse, err error)

DeleteFaceImageTemplate invokes the facebody.DeleteFaceImageTemplate API synchronously

func (*Client) DeleteFaceImageTemplateWithCallback 

func (client *Client) DeleteFaceImageTemplateWithCallback(request *DeleteFaceImageTemplateRequest, callback func(response *DeleteFaceImageTemplateResponse, err error)) <-chan int

DeleteFaceImageTemplateWithCallback invokes the facebody.DeleteFaceImageTemplate API asynchronously

func (*Client) DeleteFaceImageTemplateWithChan 

func (client *Client) DeleteFaceImageTemplateWithChan(request *DeleteFaceImageTemplateRequest) (<-chan *DeleteFaceImageTemplateResponse, <-chan error)

DeleteFaceImageTemplateWithChan invokes the facebody.DeleteFaceImageTemplate API asynchronously

func (*Client) DeleteFaceWithCallback 

func (client *Client) DeleteFaceWithCallback(request *DeleteFaceRequest, callback func(response *DeleteFaceResponse, err error)) <-chan int

DeleteFaceWithCallback invokes the facebody.DeleteFace API asynchronously

func (*Client) DeleteFaceWithChan 

func (client *Client) DeleteFaceWithChan(request *DeleteFaceRequest) (<-chan *DeleteFaceResponse, <-chan error)

DeleteFaceWithChan invokes the facebody.DeleteFace API asynchronously

func (*Client) DetectBodyCount 

func (client *Client) DetectBodyCount(request *DetectBodyCountRequest) (response *DetectBodyCountResponse, err error)

DetectBodyCount invokes the facebody.DetectBodyCount API synchronously

func (*Client) DetectBodyCountWithCallback 

func (client *Client) DetectBodyCountWithCallback(request *DetectBodyCountRequest, callback func(response *DetectBodyCountResponse, err error)) <-chan int

DetectBodyCountWithCallback invokes the facebody.DetectBodyCount API asynchronously

func (*Client) DetectBodyCountWithChan 

func (client *Client) DetectBodyCountWithChan(request *DetectBodyCountRequest) (<-chan *DetectBodyCountResponse, <-chan error)

DetectBodyCountWithChan invokes the facebody.DetectBodyCount API asynchronously

func (*Client) DetectCelebrity 

func (client *Client) DetectCelebrity(request *DetectCelebrityRequest) (response *DetectCelebrityResponse, err error)

DetectCelebrity invokes the facebody.DetectCelebrity API synchronously

func (*Client) DetectCelebrityWithCallback 

func (client *Client) DetectCelebrityWithCallback(request *DetectCelebrityRequest, callback func(response *DetectCelebrityResponse, err error)) <-chan int

DetectCelebrityWithCallback invokes the facebody.DetectCelebrity API asynchronously

func (*Client) DetectCelebrityWithChan 

func (client *Client) DetectCelebrityWithChan(request *DetectCelebrityRequest) (<-chan *DetectCelebrityResponse, <-chan error)

DetectCelebrityWithChan invokes the facebody.DetectCelebrity API asynchronously

func (*Client) DetectChefCap 

func (client *Client) DetectChefCap(request *DetectChefCapRequest) (response *DetectChefCapResponse, err error)

DetectChefCap invokes the facebody.DetectChefCap API synchronously

func (*Client) DetectChefCapWithCallback 

func (client *Client) DetectChefCapWithCallback(request *DetectChefCapRequest, callback func(response *DetectChefCapResponse, err error)) <-chan int

DetectChefCapWithCallback invokes the facebody.DetectChefCap API asynchronously

func (*Client) DetectChefCapWithChan 

func (client *Client) DetectChefCapWithChan(request *DetectChefCapRequest) (<-chan *DetectChefCapResponse, <-chan error)

DetectChefCapWithChan invokes the facebody.DetectChefCap API asynchronously

func (*Client) DetectFace 

func (client *Client) DetectFace(request *DetectFaceRequest) (response *DetectFaceResponse, err error)

DetectFace invokes the facebody.DetectFace API synchronously

func (*Client) DetectFaceWithCallback 

func (client *Client) DetectFaceWithCallback(request *DetectFaceRequest, callback func(response *DetectFaceResponse, err error)) <-chan int

DetectFaceWithCallback invokes the facebody.DetectFace API asynchronously

func (*Client) DetectFaceWithChan 

func (client *Client) DetectFaceWithChan(request *DetectFaceRequest) (<-chan *DetectFaceResponse, <-chan error)

DetectFaceWithChan invokes the facebody.DetectFace API asynchronously

func (*Client) DetectIPCPedestrian 

func (client *Client) DetectIPCPedestrian(request *DetectIPCPedestrianRequest) (response *DetectIPCPedestrianResponse, err error)

DetectIPCPedestrian invokes the facebody.DetectIPCPedestrian API synchronously

func (*Client) DetectIPCPedestrianWithCallback 

func (client *Client) DetectIPCPedestrianWithCallback(request *DetectIPCPedestrianRequest, callback func(response *DetectIPCPedestrianResponse, err error)) <-chan int

DetectIPCPedestrianWithCallback invokes the facebody.DetectIPCPedestrian API asynchronously

func (*Client) DetectIPCPedestrianWithChan 

func (client *Client) DetectIPCPedestrianWithChan(request *DetectIPCPedestrianRequest) (<-chan *DetectIPCPedestrianResponse, <-chan error)

DetectIPCPedestrianWithChan invokes the facebody.DetectIPCPedestrian API asynchronously

func (*Client) DetectLivingFace 

func (client *Client) DetectLivingFace(request *DetectLivingFaceRequest) (response *DetectLivingFaceResponse, err error)

DetectLivingFace invokes the facebody.DetectLivingFace API synchronously

func (*Client) DetectLivingFaceWithCallback 

func (client *Client) DetectLivingFaceWithCallback(request *DetectLivingFaceRequest, callback func(response *DetectLivingFaceResponse, err error)) <-chan int

DetectLivingFaceWithCallback invokes the facebody.DetectLivingFace API asynchronously

func (*Client) DetectLivingFaceWithChan 

func (client *Client) DetectLivingFaceWithChan(request *DetectLivingFaceRequest) (<-chan *DetectLivingFaceResponse, <-chan error)

DetectLivingFaceWithChan invokes the facebody.DetectLivingFace API asynchronously

func (*Client) DetectPedestrian 

func (client *Client) DetectPedestrian(request *DetectPedestrianRequest) (response *DetectPedestrianResponse, err error)

DetectPedestrian invokes the facebody.DetectPedestrian API synchronously

func (*Client) DetectPedestrianIntrusion 

func (client *Client) DetectPedestrianIntrusion(request *DetectPedestrianIntrusionRequest) (response *DetectPedestrianIntrusionResponse, err error)

DetectPedestrianIntrusion invokes the facebody.DetectPedestrianIntrusion API synchronously

func (*Client) DetectPedestrianIntrusionWithCallback 

func (client *Client) DetectPedestrianIntrusionWithCallback(request *DetectPedestrianIntrusionRequest, callback func(response *DetectPedestrianIntrusionResponse, err error)) <-chan int

DetectPedestrianIntrusionWithCallback invokes the facebody.DetectPedestrianIntrusion API asynchronously

func (*Client) DetectPedestrianIntrusionWithChan 

func (client *Client) DetectPedestrianIntrusionWithChan(request *DetectPedestrianIntrusionRequest) (<-chan *DetectPedestrianIntrusionResponse, <-chan error)

DetectPedestrianIntrusionWithChan invokes the facebody.DetectPedestrianIntrusion API asynchronously

func (*Client) DetectPedestrianWithCallback 

func (client *Client) DetectPedestrianWithCallback(request *DetectPedestrianRequest, callback func(response *DetectPedestrianResponse, err error)) <-chan int

DetectPedestrianWithCallback invokes the facebody.DetectPedestrian API asynchronously

func (*Client) DetectPedestrianWithChan 

func (client *Client) DetectPedestrianWithChan(request *DetectPedestrianRequest) (<-chan *DetectPedestrianResponse, <-chan error)

DetectPedestrianWithChan invokes the facebody.DetectPedestrian API asynchronously

func (*Client) DetectVideoLivingFace 

func (client *Client) DetectVideoLivingFace(request *DetectVideoLivingFaceRequest) (response *DetectVideoLivingFaceResponse, err error)

DetectVideoLivingFace invokes the facebody.DetectVideoLivingFace API synchronously

func (*Client) DetectVideoLivingFaceWithCallback 

func (client *Client) DetectVideoLivingFaceWithCallback(request *DetectVideoLivingFaceRequest, callback func(response *DetectVideoLivingFaceResponse, err error)) <-chan int

DetectVideoLivingFaceWithCallback invokes the facebody.DetectVideoLivingFace API asynchronously

func (*Client) DetectVideoLivingFaceWithChan 

func (client *Client) DetectVideoLivingFaceWithChan(request *DetectVideoLivingFaceRequest) (<-chan *DetectVideoLivingFaceResponse, <-chan error)

DetectVideoLivingFaceWithChan invokes the facebody.DetectVideoLivingFace API asynchronously

func (*Client) EnhanceFace 

func (client *Client) EnhanceFace(request *EnhanceFaceRequest) (response *EnhanceFaceResponse, err error)

EnhanceFace invokes the facebody.EnhanceFace API synchronously

func (*Client) EnhanceFaceWithCallback 

func (client *Client) EnhanceFaceWithCallback(request *EnhanceFaceRequest, callback func(response *EnhanceFaceResponse, err error)) <-chan int

EnhanceFaceWithCallback invokes the facebody.EnhanceFace API asynchronously

func (*Client) EnhanceFaceWithChan 

func (client *Client) EnhanceFaceWithChan(request *EnhanceFaceRequest) (<-chan *EnhanceFaceResponse, <-chan error)

EnhanceFaceWithChan invokes the facebody.EnhanceFace API asynchronously

func (*Client) ExtractFingerPrint 

func (client *Client) ExtractFingerPrint(request *ExtractFingerPrintRequest) (response *ExtractFingerPrintResponse, err error)

ExtractFingerPrint invokes the facebody.ExtractFingerPrint API synchronously

func (*Client) ExtractFingerPrintWithCallback 

func (client *Client) ExtractFingerPrintWithCallback(request *ExtractFingerPrintRequest, callback func(response *ExtractFingerPrintResponse, err error)) <-chan int

ExtractFingerPrintWithCallback invokes the facebody.ExtractFingerPrint API asynchronously

func (*Client) ExtractFingerPrintWithChan 

func (client *Client) ExtractFingerPrintWithChan(request *ExtractFingerPrintRequest) (<-chan *ExtractFingerPrintResponse, <-chan error)

ExtractFingerPrintWithChan invokes the facebody.ExtractFingerPrint API asynchronously

func (*Client) ExtractPedestrianFeatureAttr 

func (client *Client) ExtractPedestrianFeatureAttr(request *ExtractPedestrianFeatureAttrRequest) (response *ExtractPedestrianFeatureAttrResponse, err error)

ExtractPedestrianFeatureAttr invokes the facebody.ExtractPedestrianFeatureAttr API synchronously

func (*Client) ExtractPedestrianFeatureAttrWithCallback 

func (client *Client) ExtractPedestrianFeatureAttrWithCallback(request *ExtractPedestrianFeatureAttrRequest, callback func(response *ExtractPedestrianFeatureAttrResponse, err error)) <-chan int

ExtractPedestrianFeatureAttrWithCallback invokes the facebody.ExtractPedestrianFeatureAttr API asynchronously

func (*Client) ExtractPedestrianFeatureAttrWithChan 

func (client *Client) ExtractPedestrianFeatureAttrWithChan(request *ExtractPedestrianFeatureAttrRequest) (<-chan *ExtractPedestrianFeatureAttrResponse, <-chan error)

ExtractPedestrianFeatureAttrWithChan invokes the facebody.ExtractPedestrianFeatureAttr API asynchronously

func (*Client) FaceBeauty 

func (client *Client) FaceBeauty(request *FaceBeautyRequest) (response *FaceBeautyResponse, err error)

FaceBeauty invokes the facebody.FaceBeauty API synchronously

func (*Client) FaceBeautyWithCallback 

func (client *Client) FaceBeautyWithCallback(request *FaceBeautyRequest, callback func(response *FaceBeautyResponse, err error)) <-chan int

FaceBeautyWithCallback invokes the facebody.FaceBeauty API asynchronously

func (*Client) FaceBeautyWithChan 

func (client *Client) FaceBeautyWithChan(request *FaceBeautyRequest) (<-chan *FaceBeautyResponse, <-chan error)

FaceBeautyWithChan invokes the facebody.FaceBeauty API asynchronously

func (*Client) FaceFilter 

func (client *Client) FaceFilter(request *FaceFilterRequest) (response *FaceFilterResponse, err error)

FaceFilter invokes the facebody.FaceFilter API synchronously

func (*Client) FaceFilterWithCallback 

func (client *Client) FaceFilterWithCallback(request *FaceFilterRequest, callback func(response *FaceFilterResponse, err error)) <-chan int

FaceFilterWithCallback invokes the facebody.FaceFilter API asynchronously

func (*Client) FaceFilterWithChan 

func (client *Client) FaceFilterWithChan(request *FaceFilterRequest) (<-chan *FaceFilterResponse, <-chan error)

FaceFilterWithChan invokes the facebody.FaceFilter API asynchronously

func (*Client) FaceMakeup 

func (client *Client) FaceMakeup(request *FaceMakeupRequest) (response *FaceMakeupResponse, err error)

FaceMakeup invokes the facebody.FaceMakeup API synchronously

func (*Client) FaceMakeupWithCallback 

func (client *Client) FaceMakeupWithCallback(request *FaceMakeupRequest, callback func(response *FaceMakeupResponse, err error)) <-chan int

FaceMakeupWithCallback invokes the facebody.FaceMakeup API asynchronously

func (*Client) FaceMakeupWithChan 

func (client *Client) FaceMakeupWithChan(request *FaceMakeupRequest) (<-chan *FaceMakeupResponse, <-chan error)

FaceMakeupWithChan invokes the facebody.FaceMakeup API asynchronously

func (*Client) FaceTidyup 

func (client *Client) FaceTidyup(request *FaceTidyupRequest) (response *FaceTidyupResponse, err error)

FaceTidyup invokes the facebody.FaceTidyup API synchronously

func (*Client) FaceTidyupWithCallback 

func (client *Client) FaceTidyupWithCallback(request *FaceTidyupRequest, callback func(response *FaceTidyupResponse, err error)) <-chan int

FaceTidyupWithCallback invokes the facebody.FaceTidyup API asynchronously

func (*Client) FaceTidyupWithChan 

func (client *Client) FaceTidyupWithChan(request *FaceTidyupRequest) (<-chan *FaceTidyupResponse, <-chan error)

FaceTidyupWithChan invokes the facebody.FaceTidyup API asynchronously

func (*Client) GenRealPersonVerificationToken 

func (client *Client) GenRealPersonVerificationToken(request *GenRealPersonVerificationTokenRequest) (response *GenRealPersonVerificationTokenResponse, err error)

GenRealPersonVerificationToken invokes the facebody.GenRealPersonVerificationToken API synchronously

func (*Client) GenRealPersonVerificationTokenWithCallback 

func (client *Client) GenRealPersonVerificationTokenWithCallback(request *GenRealPersonVerificationTokenRequest, callback func(response *GenRealPersonVerificationTokenResponse, err error)) <-chan int

GenRealPersonVerificationTokenWithCallback invokes the facebody.GenRealPersonVerificationToken API asynchronously

func (*Client) GenRealPersonVerificationTokenWithChan 

func (client *Client) GenRealPersonVerificationTokenWithChan(request *GenRealPersonVerificationTokenRequest) (<-chan *GenRealPersonVerificationTokenResponse, <-chan error)

GenRealPersonVerificationTokenWithChan invokes the facebody.GenRealPersonVerificationToken API asynchronously

func (*Client) GenerateHumanAnimeStyle 

func (client *Client) GenerateHumanAnimeStyle(request *GenerateHumanAnimeStyleRequest) (response *GenerateHumanAnimeStyleResponse, err error)

GenerateHumanAnimeStyle invokes the facebody.GenerateHumanAnimeStyle API synchronously

func (*Client) GenerateHumanAnimeStyleWithCallback 

func (client *Client) GenerateHumanAnimeStyleWithCallback(request *GenerateHumanAnimeStyleRequest, callback func(response *GenerateHumanAnimeStyleResponse, err error)) <-chan int

GenerateHumanAnimeStyleWithCallback invokes the facebody.GenerateHumanAnimeStyle API asynchronously

func (*Client) GenerateHumanAnimeStyleWithChan 

func (client *Client) GenerateHumanAnimeStyleWithChan(request *GenerateHumanAnimeStyleRequest) (<-chan *GenerateHumanAnimeStyleResponse, <-chan error)

GenerateHumanAnimeStyleWithChan invokes the facebody.GenerateHumanAnimeStyle API asynchronously

func (*Client) GenerateHumanSketchStyle 

func (client *Client) GenerateHumanSketchStyle(request *GenerateHumanSketchStyleRequest) (response *GenerateHumanSketchStyleResponse, err error)

GenerateHumanSketchStyle invokes the facebody.GenerateHumanSketchStyle API synchronously

func (*Client) GenerateHumanSketchStyleWithCallback 

func (client *Client) GenerateHumanSketchStyleWithCallback(request *GenerateHumanSketchStyleRequest, callback func(response *GenerateHumanSketchStyleResponse, err error)) <-chan int

GenerateHumanSketchStyleWithCallback invokes the facebody.GenerateHumanSketchStyle API asynchronously

func (*Client) GenerateHumanSketchStyleWithChan 

func (client *Client) GenerateHumanSketchStyleWithChan(request *GenerateHumanSketchStyleRequest) (<-chan *GenerateHumanSketchStyleResponse, <-chan error)

GenerateHumanSketchStyleWithChan invokes the facebody.GenerateHumanSketchStyle API asynchronously

func (*Client) GetFaceEntity 

func (client *Client) GetFaceEntity(request *GetFaceEntityRequest) (response *GetFaceEntityResponse, err error)

GetFaceEntity invokes the facebody.GetFaceEntity API synchronously

func (*Client) GetFaceEntityWithCallback 

func (client *Client) GetFaceEntityWithCallback(request *GetFaceEntityRequest, callback func(response *GetFaceEntityResponse, err error)) <-chan int

GetFaceEntityWithCallback invokes the facebody.GetFaceEntity API asynchronously

func (*Client) GetFaceEntityWithChan 

func (client *Client) GetFaceEntityWithChan(request *GetFaceEntityRequest) (<-chan *GetFaceEntityResponse, <-chan error)

GetFaceEntityWithChan invokes the facebody.GetFaceEntity API asynchronously

func (*Client) GetRealPersonVerificationResult 

func (client *Client) GetRealPersonVerificationResult(request *GetRealPersonVerificationResultRequest) (response *GetRealPersonVerificationResultResponse, err error)

GetRealPersonVerificationResult invokes the facebody.GetRealPersonVerificationResult API synchronously

func (*Client) GetRealPersonVerificationResultWithCallback 

func (client *Client) GetRealPersonVerificationResultWithCallback(request *GetRealPersonVerificationResultRequest, callback func(response *GetRealPersonVerificationResultResponse, err error)) <-chan int

GetRealPersonVerificationResultWithCallback invokes the facebody.GetRealPersonVerificationResult API asynchronously

func (*Client) GetRealPersonVerificationResultWithChan 

func (client *Client) GetRealPersonVerificationResultWithChan(request *GetRealPersonVerificationResultRequest) (<-chan *GetRealPersonVerificationResultResponse, <-chan error)

GetRealPersonVerificationResultWithChan invokes the facebody.GetRealPersonVerificationResult API asynchronously

func (*Client) HandPosture 

func (client *Client) HandPosture(request *HandPostureRequest) (response *HandPostureResponse, err error)

HandPosture invokes the facebody.HandPosture API synchronously

func (*Client) HandPostureWithCallback 

func (client *Client) HandPostureWithCallback(request *HandPostureRequest, callback func(response *HandPostureResponse, err error)) <-chan int

HandPostureWithCallback invokes the facebody.HandPosture API asynchronously

func (*Client) HandPostureWithChan 

func (client *Client) HandPostureWithChan(request *HandPostureRequest) (<-chan *HandPostureResponse, <-chan error)

HandPostureWithChan invokes the facebody.HandPosture API asynchronously

func (*Client) LiquifyFace 

func (client *Client) LiquifyFace(request *LiquifyFaceRequest) (response *LiquifyFaceResponse, err error)

LiquifyFace invokes the facebody.LiquifyFace API synchronously

func (*Client) LiquifyFaceWithCallback 

func (client *Client) LiquifyFaceWithCallback(request *LiquifyFaceRequest, callback func(response *LiquifyFaceResponse, err error)) <-chan int

LiquifyFaceWithCallback invokes the facebody.LiquifyFace API asynchronously

func (*Client) LiquifyFaceWithChan 

func (client *Client) LiquifyFaceWithChan(request *LiquifyFaceRequest) (<-chan *LiquifyFaceResponse, <-chan error)

LiquifyFaceWithChan invokes the facebody.LiquifyFace API asynchronously

func (*Client) ListFaceDbs 

func (client *Client) ListFaceDbs(request *ListFaceDbsRequest) (response *ListFaceDbsResponse, err error)

ListFaceDbs invokes the facebody.ListFaceDbs API synchronously

func (*Client) ListFaceDbsWithCallback 

func (client *Client) ListFaceDbsWithCallback(request *ListFaceDbsRequest, callback func(response *ListFaceDbsResponse, err error)) <-chan int

ListFaceDbsWithCallback invokes the facebody.ListFaceDbs API asynchronously

func (*Client) ListFaceDbsWithChan 

func (client *Client) ListFaceDbsWithChan(request *ListFaceDbsRequest) (<-chan *ListFaceDbsResponse, <-chan error)

ListFaceDbsWithChan invokes the facebody.ListFaceDbs API asynchronously

func (*Client) ListFaceEntities 

func (client *Client) ListFaceEntities(request *ListFaceEntitiesRequest) (response *ListFaceEntitiesResponse, err error)

ListFaceEntities invokes the facebody.ListFaceEntities API synchronously

func (*Client) ListFaceEntitiesWithCallback 

func (client *Client) ListFaceEntitiesWithCallback(request *ListFaceEntitiesRequest, callback func(response *ListFaceEntitiesResponse, err error)) <-chan int

ListFaceEntitiesWithCallback invokes the facebody.ListFaceEntities API asynchronously

func (*Client) ListFaceEntitiesWithChan 

func (client *Client) ListFaceEntitiesWithChan(request *ListFaceEntitiesRequest) (<-chan *ListFaceEntitiesResponse, <-chan error)

ListFaceEntitiesWithChan invokes the facebody.ListFaceEntities API asynchronously

func (*Client) MergeImageFace 

func (client *Client) MergeImageFace(request *MergeImageFaceRequest) (response *MergeImageFaceResponse, err error)

MergeImageFace invokes the facebody.MergeImageFace API synchronously

func (*Client) MergeImageFaceWithCallback 

func (client *Client) MergeImageFaceWithCallback(request *MergeImageFaceRequest, callback func(response *MergeImageFaceResponse, err error)) <-chan int

MergeImageFaceWithCallback invokes the facebody.MergeImageFace API asynchronously

func (*Client) MergeImageFaceWithChan 

func (client *Client) MergeImageFaceWithChan(request *MergeImageFaceRequest) (<-chan *MergeImageFaceResponse, <-chan error)

MergeImageFaceWithChan invokes the facebody.MergeImageFace API asynchronously

func (*Client) MonitorExamination 

func (client *Client) MonitorExamination(request *MonitorExaminationRequest) (response *MonitorExaminationResponse, err error)

MonitorExamination invokes the facebody.MonitorExamination API synchronously

func (*Client) MonitorExaminationWithCallback 

func (client *Client) MonitorExaminationWithCallback(request *MonitorExaminationRequest, callback func(response *MonitorExaminationResponse, err error)) <-chan int

MonitorExaminationWithCallback invokes the facebody.MonitorExamination API asynchronously

func (*Client) MonitorExaminationWithChan 

func (client *Client) MonitorExaminationWithChan(request *MonitorExaminationRequest) (<-chan *MonitorExaminationResponse, <-chan error)

MonitorExaminationWithChan invokes the facebody.MonitorExamination API asynchronously

func (*Client) PedestrianDetectAttribute 

func (client *Client) PedestrianDetectAttribute(request *PedestrianDetectAttributeRequest) (response *PedestrianDetectAttributeResponse, err error)

PedestrianDetectAttribute invokes the facebody.PedestrianDetectAttribute API synchronously

func (*Client) PedestrianDetectAttributeWithCallback 

func (client *Client) PedestrianDetectAttributeWithCallback(request *PedestrianDetectAttributeRequest, callback func(response *PedestrianDetectAttributeResponse, err error)) <-chan int

PedestrianDetectAttributeWithCallback invokes the facebody.PedestrianDetectAttribute API asynchronously

func (*Client) PedestrianDetectAttributeWithChan 

func (client *Client) PedestrianDetectAttributeWithChan(request *PedestrianDetectAttributeRequest) (<-chan *PedestrianDetectAttributeResponse, <-chan error)

PedestrianDetectAttributeWithChan invokes the facebody.PedestrianDetectAttribute API asynchronously

func (*Client) QueryFaceImageTemplate 

func (client *Client) QueryFaceImageTemplate(request *QueryFaceImageTemplateRequest) (response *QueryFaceImageTemplateResponse, err error)

QueryFaceImageTemplate invokes the facebody.QueryFaceImageTemplate API synchronously

func (*Client) QueryFaceImageTemplateWithCallback 

func (client *Client) QueryFaceImageTemplateWithCallback(request *QueryFaceImageTemplateRequest, callback func(response *QueryFaceImageTemplateResponse, err error)) <-chan int

QueryFaceImageTemplateWithCallback invokes the facebody.QueryFaceImageTemplate API asynchronously

func (*Client) QueryFaceImageTemplateWithChan 

func (client *Client) QueryFaceImageTemplateWithChan(request *QueryFaceImageTemplateRequest) (<-chan *QueryFaceImageTemplateResponse, <-chan error)

QueryFaceImageTemplateWithChan invokes the facebody.QueryFaceImageTemplate API asynchronously

func (*Client) RecognizeAction 

func (client *Client) RecognizeAction(request *RecognizeActionRequest) (response *RecognizeActionResponse, err error)

RecognizeAction invokes the facebody.RecognizeAction API synchronously

func (*Client) RecognizeActionWithCallback 

func (client *Client) RecognizeActionWithCallback(request *RecognizeActionRequest, callback func(response *RecognizeActionResponse, err error)) <-chan int

RecognizeActionWithCallback invokes the facebody.RecognizeAction API asynchronously

func (*Client) RecognizeActionWithChan 

func (client *Client) RecognizeActionWithChan(request *RecognizeActionRequest) (<-chan *RecognizeActionResponse, <-chan error)

RecognizeActionWithChan invokes the facebody.RecognizeAction API asynchronously

func (*Client) RecognizeExpression 

func (client *Client) RecognizeExpression(request *RecognizeExpressionRequest) (response *RecognizeExpressionResponse, err error)

RecognizeExpression invokes the facebody.RecognizeExpression API synchronously

func (*Client) RecognizeExpressionWithCallback 

func (client *Client) RecognizeExpressionWithCallback(request *RecognizeExpressionRequest, callback func(response *RecognizeExpressionResponse, err error)) <-chan int

RecognizeExpressionWithCallback invokes the facebody.RecognizeExpression API asynchronously

func (*Client) RecognizeExpressionWithChan 

func (client *Client) RecognizeExpressionWithChan(request *RecognizeExpressionRequest) (<-chan *RecognizeExpressionResponse, <-chan error)

RecognizeExpressionWithChan invokes the facebody.RecognizeExpression API asynchronously

func (*Client) RecognizeFace 

func (client *Client) RecognizeFace(request *RecognizeFaceRequest) (response *RecognizeFaceResponse, err error)

RecognizeFace invokes the facebody.RecognizeFace API synchronously

func (*Client) RecognizeFaceWithCallback 

func (client *Client) RecognizeFaceWithCallback(request *RecognizeFaceRequest, callback func(response *RecognizeFaceResponse, err error)) <-chan int

RecognizeFaceWithCallback invokes the facebody.RecognizeFace API asynchronously

func (*Client) RecognizeFaceWithChan 

func (client *Client) RecognizeFaceWithChan(request *RecognizeFaceRequest) (<-chan *RecognizeFaceResponse, <-chan error)

RecognizeFaceWithChan invokes the facebody.RecognizeFace API asynchronously

func (*Client) RecognizeHandGesture 

func (client *Client) RecognizeHandGesture(request *RecognizeHandGestureRequest) (response *RecognizeHandGestureResponse, err error)

RecognizeHandGesture invokes the facebody.RecognizeHandGesture API synchronously

func (*Client) RecognizeHandGestureWithCallback 

func (client *Client) RecognizeHandGestureWithCallback(request *RecognizeHandGestureRequest, callback func(response *RecognizeHandGestureResponse, err error)) <-chan int

RecognizeHandGestureWithCallback invokes the facebody.RecognizeHandGesture API asynchronously

func (*Client) RecognizeHandGestureWithChan 

func (client *Client) RecognizeHandGestureWithChan(request *RecognizeHandGestureRequest) (<-chan *RecognizeHandGestureResponse, <-chan error)

RecognizeHandGestureWithChan invokes the facebody.RecognizeHandGesture API asynchronously

func (*Client) RecognizePublicFace 

func (client *Client) RecognizePublicFace(request *RecognizePublicFaceRequest) (response *RecognizePublicFaceResponse, err error)

RecognizePublicFace invokes the facebody.RecognizePublicFace API synchronously

func (*Client) RecognizePublicFaceWithCallback 

func (client *Client) RecognizePublicFaceWithCallback(request *RecognizePublicFaceRequest, callback func(response *RecognizePublicFaceResponse, err error)) <-chan int

RecognizePublicFaceWithCallback invokes the facebody.RecognizePublicFace API asynchronously

func (*Client) RecognizePublicFaceWithChan 

func (client *Client) RecognizePublicFaceWithChan(request *RecognizePublicFaceRequest) (<-chan *RecognizePublicFaceResponse, <-chan error)

RecognizePublicFaceWithChan invokes the facebody.RecognizePublicFace API asynchronously

func (*Client) RetouchBody 

func (client *Client) RetouchBody(request *RetouchBodyRequest) (response *RetouchBodyResponse, err error)

RetouchBody invokes the facebody.RetouchBody API synchronously

func (*Client) RetouchBodyWithCallback 

func (client *Client) RetouchBodyWithCallback(request *RetouchBodyRequest, callback func(response *RetouchBodyResponse, err error)) <-chan int

RetouchBodyWithCallback invokes the facebody.RetouchBody API asynchronously

func (*Client) RetouchBodyWithChan 

func (client *Client) RetouchBodyWithChan(request *RetouchBodyRequest) (<-chan *RetouchBodyResponse, <-chan error)

RetouchBodyWithChan invokes the facebody.RetouchBody API asynchronously

func (*Client) RetouchSkin 

func (client *Client) RetouchSkin(request *RetouchSkinRequest) (response *RetouchSkinResponse, err error)

RetouchSkin invokes the facebody.RetouchSkin API synchronously

func (*Client) RetouchSkinWithCallback 

func (client *Client) RetouchSkinWithCallback(request *RetouchSkinRequest, callback func(response *RetouchSkinResponse, err error)) <-chan int

RetouchSkinWithCallback invokes the facebody.RetouchSkin API asynchronously

func (*Client) RetouchSkinWithChan 

func (client *Client) RetouchSkinWithChan(request *RetouchSkinRequest) (<-chan *RetouchSkinResponse, <-chan error)

RetouchSkinWithChan invokes the facebody.RetouchSkin API asynchronously

func (*Client) SearchFace 

func (client *Client) SearchFace(request *SearchFaceRequest) (response *SearchFaceResponse, err error)

SearchFace invokes the facebody.SearchFace API synchronously

func (*Client) SearchFaceWithCallback 

func (client *Client) SearchFaceWithCallback(request *SearchFaceRequest, callback func(response *SearchFaceResponse, err error)) <-chan int

SearchFaceWithCallback invokes the facebody.SearchFace API asynchronously

func (*Client) SearchFaceWithChan 

func (client *Client) SearchFaceWithChan(request *SearchFaceRequest) (<-chan *SearchFaceResponse, <-chan error)

SearchFaceWithChan invokes the facebody.SearchFace API asynchronously

func (*Client) SwapFacialFeatures 

func (client *Client) SwapFacialFeatures(request *SwapFacialFeaturesRequest) (response *SwapFacialFeaturesResponse, err error)

SwapFacialFeatures invokes the facebody.SwapFacialFeatures API synchronously

func (*Client) SwapFacialFeaturesWithCallback 

func (client *Client) SwapFacialFeaturesWithCallback(request *SwapFacialFeaturesRequest, callback func(response *SwapFacialFeaturesResponse, err error)) <-chan int

SwapFacialFeaturesWithCallback invokes the facebody.SwapFacialFeatures API asynchronously

func (*Client) SwapFacialFeaturesWithChan 

func (client *Client) SwapFacialFeaturesWithChan(request *SwapFacialFeaturesRequest) (<-chan *SwapFacialFeaturesResponse, <-chan error)

SwapFacialFeaturesWithChan invokes the facebody.SwapFacialFeatures API asynchronously

func (*Client) UpdateFaceEntity 

func (client *Client) UpdateFaceEntity(request *UpdateFaceEntityRequest) (response *UpdateFaceEntityResponse, err error)

UpdateFaceEntity invokes the facebody.UpdateFaceEntity API synchronously

func (*Client) UpdateFaceEntityWithCallback 

func (client *Client) UpdateFaceEntityWithCallback(request *UpdateFaceEntityRequest, callback func(response *UpdateFaceEntityResponse, err error)) <-chan int

UpdateFaceEntityWithCallback invokes the facebody.UpdateFaceEntity API asynchronously

func (*Client) UpdateFaceEntityWithChan 

func (client *Client) UpdateFaceEntityWithChan(request *UpdateFaceEntityRequest) (<-chan *UpdateFaceEntityResponse, <-chan error)

UpdateFaceEntityWithChan invokes the facebody.UpdateFaceEntity API asynchronously

func (*Client) VerifyFaceMask 

func (client *Client) VerifyFaceMask(request *VerifyFaceMaskRequest) (response *VerifyFaceMaskResponse, err error)

VerifyFaceMask invokes the facebody.VerifyFaceMask API synchronously

func (*Client) VerifyFaceMaskWithCallback 

func (client *Client) VerifyFaceMaskWithCallback(request *VerifyFaceMaskRequest, callback func(response *VerifyFaceMaskResponse, err error)) <-chan int

VerifyFaceMaskWithCallback invokes the facebody.VerifyFaceMask API asynchronously

func (*Client) VerifyFaceMaskWithChan 

func (client *Client) VerifyFaceMaskWithChan(request *VerifyFaceMaskRequest) (<-chan *VerifyFaceMaskResponse, <-chan error)

VerifyFaceMaskWithChan invokes the facebody.VerifyFaceMask API asynchronously

type CompareFaceRequest 

type CompareFaceRequest struct {
	*requests.RpcRequest
	ImageDataA            string           `position:"Body" name:"ImageDataA"`
	ImageDataB            string           `position:"Body" name:"ImageDataB"`
	FormatResultToJson    requests.Boolean `position:"Query" name:"FormatResultToJson"`
	QualityScoreThreshold requests.Float   `position:"Body" name:"QualityScoreThreshold"`
	ImageURLB             string           `position:"Body" name:"ImageURLB"`
	ImageURLA             string           `position:"Body" name:"ImageURLA"`
	OssFile               string           `position:"Query" name:"OssFile"`
	ImageType             requests.Integer `position:"Body" name:"ImageType"`
	RequestProxyBy        string           `position:"Query" name:"RequestProxyBy"`
}

CompareFaceRequest is the request struct for api CompareFace

func CreateCompareFaceRequest 

func CreateCompareFaceRequest() (request *CompareFaceRequest)

CreateCompareFaceRequest creates a request to invoke CompareFace API

type CompareFaceResponse 

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

CompareFaceResponse is the response struct for api CompareFace

func CreateCompareFaceResponse 

func CreateCompareFaceResponse() (response *CompareFaceResponse)

CreateCompareFaceResponse creates a response to parse from CompareFace response

type CountCrowdRequest 

type CountCrowdRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	IsShow             requests.Boolean `position:"Body" name:"IsShow"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

CountCrowdRequest is the request struct for api CountCrowd

func CreateCountCrowdRequest 

func CreateCountCrowdRequest() (request *CountCrowdRequest)

CreateCountCrowdRequest creates a request to invoke CountCrowd API

type CountCrowdResponse 

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

CountCrowdResponse is the response struct for api CountCrowd

func CreateCountCrowdResponse 

func CreateCountCrowdResponse() (response *CountCrowdResponse)

CreateCountCrowdResponse creates a response to parse from CountCrowd response

type CreateFaceDbRequest 

type CreateFaceDbRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Name               string           `position:"Body" name:"Name"`
}

CreateFaceDbRequest is the request struct for api CreateFaceDb

func CreateCreateFaceDbRequest 

func CreateCreateFaceDbRequest() (request *CreateFaceDbRequest)

CreateCreateFaceDbRequest creates a request to invoke CreateFaceDb API

type CreateFaceDbResponse 

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

CreateFaceDbResponse is the response struct for api CreateFaceDb

func CreateCreateFaceDbResponse 

func CreateCreateFaceDbResponse() (response *CreateFaceDbResponse)

CreateCreateFaceDbResponse creates a response to parse from CreateFaceDb response

type Data 

type Data struct {
	TemplateId           string                `json:"TemplateId" xml:"TemplateId"`
	Confidence           float64               `json:"Confidence" xml:"Confidence"`
	Age                  string                `json:"Age" xml:"Age"`
	VerificationToken    string                `json:"VerificationToken" xml:"VerificationToken"`
	MaterialMatch        string                `json:"MaterialMatch" xml:"MaterialMatch"`
	HairScore            float64               `json:"HairScore" xml:"HairScore"`
	TotalCount           int                   `json:"TotalCount" xml:"TotalCount"`
	ImageURL             string                `json:"ImageURL" xml:"ImageURL"`
	ObjType              string                `json:"ObjType" xml:"ObjType"`
	MaskRef              int                   `json:"MaskRef" xml:"MaskRef"`
	QualityScoreA        float64               `json:"QualityScoreA" xml:"QualityScoreA"`
	ObjTypeScore         float64               `json:"ObjTypeScore" xml:"ObjTypeScore"`
	Token                string                `json:"Token" xml:"Token"`
	HotMap               string                `json:"HotMap" xml:"HotMap"`
	QualityScoreB        float64               `json:"QualityScoreB" xml:"QualityScoreB"`
	Action               string                `json:"Action" xml:"Action"`
	ChatScore            float64               `json:"ChatScore" xml:"ChatScore"`
	OrientationScore     float64               `json:"OrientationScore" xml:"OrientationScore"`
	DbName               string                `json:"DbName" xml:"DbName"`
	FingerPrint          string                `json:"FingerPrint" xml:"FingerPrint"`
	IsMaskA              int64                 `json:"IsMaskA" xml:"IsMaskA"`
	EntityId             string                `json:"EntityId" xml:"EntityId"`
	Gender               string                `json:"Gender" xml:"Gender"`
	XFlowURL             string                `json:"XFlowURL" xml:"XFlowURL"`
	PeopleNumber         int                   `json:"PeopleNumber" xml:"PeopleNumber"`
	ImageHeight          int64                 `json:"ImageHeight" xml:"ImageHeight"`
	LowerType            string                `json:"LowerType" xml:"LowerType"`
	Width                int                   `json:"Width" xml:"Width"`
	Passed               bool                  `json:"Passed" xml:"Passed"`
	UpperColorScore      float64               `json:"UpperColorScore" xml:"UpperColorScore"`
	ImageWidth           int64                 `json:"ImageWidth" xml:"ImageWidth"`
	Hair                 string                `json:"Hair" xml:"Hair"`
	MessageTips          string                `json:"MessageTips" xml:"MessageTips"`
	Threshold            float64               `json:"Threshold" xml:"Threshold"`
	DenseFeatureLength   int                   `json:"DenseFeatureLength" xml:"DenseFeatureLength"`
	AgeScore             float64               `json:"AgeScore" xml:"AgeScore"`
	LowerColor           string                `json:"LowerColor" xml:"LowerColor"`
	QualitieScore        float64               `json:"QualitieScore" xml:"QualitieScore"`
	LowerColorScore      float64               `json:"LowerColorScore" xml:"LowerColorScore"`
	IdentityInfo         string                `json:"IdentityInfo" xml:"IdentityInfo"`
	QualityScore         float64               `json:"QualityScore" xml:"QualityScore"`
	Orientation          string                `json:"Orientation" xml:"Orientation"`
	FaceId               string                `json:"FaceId" xml:"FaceId"`
	UpperType            string                `json:"UpperType" xml:"UpperType"`
	LandmarkCount        int                   `json:"LandmarkCount" xml:"LandmarkCount"`
	Feature              string                `json:"Feature" xml:"Feature"`
	UpperTypeScore       float64               `json:"UpperTypeScore" xml:"UpperTypeScore"`
	UpperColor           string                `json:"UpperColor" xml:"UpperColor"`
	IsMaskB              int64                 `json:"IsMaskB" xml:"IsMaskB"`
	LowerTypeScore       float64               `json:"LowerTypeScore" xml:"LowerTypeScore"`
	PersonNumber         int                   `json:"PersonNumber" xml:"PersonNumber"`
	GenderScore          float64               `json:"GenderScore" xml:"GenderScore"`
	Mask                 int                   `json:"Mask" xml:"Mask"`
	Height               int                   `json:"Height" xml:"Height"`
	Labels               string                `json:"Labels" xml:"Labels"`
	FaceCount            int                   `json:"FaceCount" xml:"FaceCount"`
	YFlowURL             string                `json:"YFlowURL" xml:"YFlowURL"`
	GenderList           []int                 `json:"GenderList" xml:"GenderList"`
	PoseList             []float64             `json:"PoseList" xml:"PoseList"`
	Pupils               []float64             `json:"Pupils" xml:"Pupils"`
	Glasses              []int                 `json:"Glasses" xml:"Glasses"`
	RectBList            []int                 `json:"RectBList" xml:"RectBList"`
	DenseFeatures        []string              `json:"DenseFeatures" xml:"DenseFeatures"`
	RectangleRef         []int                 `json:"RectangleRef" xml:"RectangleRef"`
	HatList              []int                 `json:"HatList" xml:"HatList"`
	Rectangle            []int                 `json:"Rectangle" xml:"Rectangle"`
	Thresholds           []float64             `json:"Thresholds" xml:"Thresholds"`
	Landmarks            []float64             `json:"Landmarks" xml:"Landmarks"`
	FaceRectangles       []int                 `json:"FaceRectangles" xml:"FaceRectangles"`
	BeautyList           []float64             `json:"BeautyList" xml:"BeautyList"`
	Masks                []int64               `json:"Masks" xml:"Masks"`
	RectAList            []int                 `json:"RectAList" xml:"RectAList"`
	AgeList              []int                 `json:"AgeList" xml:"AgeList"`
	FaceProbabilityList  []float64             `json:"FaceProbabilityList" xml:"FaceProbabilityList"`
	Expressions          []int                 `json:"Expressions" xml:"Expressions"`
	LandmarksAList       []int64               `json:"LandmarksAList" xml:"LandmarksAList"`
	LandmarksBList       []int64               `json:"LandmarksBList" xml:"LandmarksBList"`
	Qualities            Qualities             `json:"Qualities" xml:"Qualities"`
	PersonInfo           PersonInfo            `json:"PersonInfo" xml:"PersonInfo"`
	FaceInfo             FaceInfo              `json:"FaceInfo" xml:"FaceInfo"`
	MetaObject           MetaObject            `json:"MetaObject" xml:"MetaObject"`
	Elements             []ElementsItem        `json:"Elements" xml:"Elements"`
	Faces                []Face                `json:"Faces" xml:"Faces"`
	FailedFaces          []FailedFacesItem     `json:"FailedFaces" xml:"FailedFaces"`
	ImageInfoList        []ImageInfoListItem   `json:"ImageInfoList" xml:"ImageInfoList"`
	Outputs              []Output              `json:"Outputs" xml:"Outputs"`
	DbList               []DbListItem          `json:"DbList" xml:"DbList"`
	Entities             []Entity              `json:"Entities" xml:"Entities"`
	InsertedFaces        []InsertedFacesItem   `json:"InsertedFaces" xml:"InsertedFaces"`
	MatchList            []MatchListItem       `json:"MatchList" xml:"MatchList"`
	FaceRecognizeResults []FaceRecognizeResult `json:"FaceRecognizeResults" xml:"FaceRecognizeResults"`
}

Data is a nested struct in facebody response

type DataInDetectLivingFace 

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

DataInDetectLivingFace is a nested struct in facebody response

type DataInDetectPedestrian 

type DataInDetectPedestrian struct {
	Width    int       `json:"Width" xml:"Width"`
	Height   int       `json:"Height" xml:"Height"`
	Elements []Element `json:"Elements" xml:"Elements"`
}

DataInDetectPedestrian is a nested struct in facebody response

type DataInDetectVideoLivingFace 

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

DataInDetectVideoLivingFace is a nested struct in facebody response

type DataInPedestrianDetectAttribute 

type DataInPedestrianDetectAttribute struct {
	PersonNumber int              `json:"PersonNumber" xml:"PersonNumber"`
	Width        int64            `json:"Width" xml:"Width"`
	Height       int64            `json:"Height" xml:"Height"`
	Attributes   []AttributesItem `json:"Attributes" xml:"Attributes"`
	Boxes        []BoxesItem      `json:"Boxes" xml:"Boxes"`
}

DataInPedestrianDetectAttribute is a nested struct in facebody response

type DataInRecognizeAction 

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

DataInRecognizeAction is a nested struct in facebody response

type DataInRecognizeExpression 

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

DataInRecognizeExpression is a nested struct in facebody response

type DataInRecognizeHandGesture 

type DataInRecognizeHandGesture struct {
	Type   string  `json:"Type" xml:"Type"`
	X      int64   `json:"X" xml:"X"`
	Y      int64   `json:"Y" xml:"Y"`
	Width  int64   `json:"Width" xml:"Width"`
	Height int64   `json:"Height" xml:"Height"`
	Score  float64 `json:"Score" xml:"Score"`
}

DataInRecognizeHandGesture is a nested struct in facebody response

type DataInRecognizePublicFace 

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

DataInRecognizePublicFace is a nested struct in facebody response

type DbList 

type DbList struct {
	DbListItem []DbListItem `json:"DbList" xml:"DbList"`
}

DbList is a nested struct in facebody response

type DbListItem 

type DbListItem struct {
	Name string `json:"Name" xml:"Name"`
}

DbListItem is a nested struct in facebody response

type DeleteFaceDbRequest 

type DeleteFaceDbRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Name               string           `position:"Body" name:"Name"`
}

DeleteFaceDbRequest is the request struct for api DeleteFaceDb

func CreateDeleteFaceDbRequest 

func CreateDeleteFaceDbRequest() (request *DeleteFaceDbRequest)

CreateDeleteFaceDbRequest creates a request to invoke DeleteFaceDb API

type DeleteFaceDbResponse 

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

DeleteFaceDbResponse is the response struct for api DeleteFaceDb

func CreateDeleteFaceDbResponse 

func CreateDeleteFaceDbResponse() (response *DeleteFaceDbResponse)

CreateDeleteFaceDbResponse creates a response to parse from DeleteFaceDb response

type DeleteFaceEntityRequest 

type DeleteFaceEntityRequest struct {
	*requests.RpcRequest
	EntityId           string           `position:"Body" name:"EntityId"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	DbName             string           `position:"Body" name:"DbName"`
}

DeleteFaceEntityRequest is the request struct for api DeleteFaceEntity

func CreateDeleteFaceEntityRequest 

func CreateDeleteFaceEntityRequest() (request *DeleteFaceEntityRequest)

CreateDeleteFaceEntityRequest creates a request to invoke DeleteFaceEntity API

type DeleteFaceEntityResponse 

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

DeleteFaceEntityResponse is the response struct for api DeleteFaceEntity

func CreateDeleteFaceEntityResponse 

func CreateDeleteFaceEntityResponse() (response *DeleteFaceEntityResponse)

CreateDeleteFaceEntityResponse creates a response to parse from DeleteFaceEntity response

type DeleteFaceImageTemplateRequest 

type DeleteFaceImageTemplateRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	UserId             string           `position:"Body" name:"UserId"`
	OssFile            string           `position:"Query" name:"OssFile"`
	TemplateId         string           `position:"Body" name:"TemplateId"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
}

DeleteFaceImageTemplateRequest is the request struct for api DeleteFaceImageTemplate

func CreateDeleteFaceImageTemplateRequest 

func CreateDeleteFaceImageTemplateRequest() (request *DeleteFaceImageTemplateRequest)

CreateDeleteFaceImageTemplateRequest creates a request to invoke DeleteFaceImageTemplate API

type DeleteFaceImageTemplateResponse 

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

DeleteFaceImageTemplateResponse is the response struct for api DeleteFaceImageTemplate

func CreateDeleteFaceImageTemplateResponse 

func CreateDeleteFaceImageTemplateResponse() (response *DeleteFaceImageTemplateResponse)

CreateDeleteFaceImageTemplateResponse creates a response to parse from DeleteFaceImageTemplate response

type DeleteFaceRequest 

type DeleteFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	FaceId             string           `position:"Body" name:"FaceId"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	DbName             string           `position:"Body" name:"DbName"`
}

DeleteFaceRequest is the request struct for api DeleteFace

func CreateDeleteFaceRequest 

func CreateDeleteFaceRequest() (request *DeleteFaceRequest)

CreateDeleteFaceRequest creates a request to invoke DeleteFace API

type DeleteFaceResponse 

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

DeleteFaceResponse is the response struct for api DeleteFace

func CreateDeleteFaceResponse 

func CreateDeleteFaceResponse() (response *DeleteFaceResponse)

CreateDeleteFaceResponse creates a response to parse from DeleteFace response

type DenseFeatures 

type DenseFeatures struct {
	DenseFeature []string `json:"DenseFeature" xml:"DenseFeature"`
}

DenseFeatures is a nested struct in facebody response

type DetectBodyCountRequest 

type DetectBodyCountRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

DetectBodyCountRequest is the request struct for api DetectBodyCount

func CreateDetectBodyCountRequest 

func CreateDetectBodyCountRequest() (request *DetectBodyCountRequest)

CreateDetectBodyCountRequest creates a request to invoke DetectBodyCount API

type DetectBodyCountResponse 

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

DetectBodyCountResponse is the response struct for api DetectBodyCount

func CreateDetectBodyCountResponse 

func CreateDetectBodyCountResponse() (response *DetectBodyCountResponse)

CreateDetectBodyCountResponse creates a response to parse from DetectBodyCount response

type DetectCelebrityRequest 

type DetectCelebrityRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

DetectCelebrityRequest is the request struct for api DetectCelebrity

func CreateDetectCelebrityRequest 

func CreateDetectCelebrityRequest() (request *DetectCelebrityRequest)

CreateDetectCelebrityRequest creates a request to invoke DetectCelebrity API

type DetectCelebrityResponse 

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

DetectCelebrityResponse is the response struct for api DetectCelebrity

func CreateDetectCelebrityResponse 

func CreateDetectCelebrityResponse() (response *DetectCelebrityResponse)

CreateDetectCelebrityResponse creates a response to parse from DetectCelebrity response

type DetectChefCapRequest 

type DetectChefCapRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

DetectChefCapRequest is the request struct for api DetectChefCap

func CreateDetectChefCapRequest 

func CreateDetectChefCapRequest() (request *DetectChefCapRequest)

CreateDetectChefCapRequest creates a request to invoke DetectChefCap API

type DetectChefCapResponse 

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

DetectChefCapResponse is the response struct for api DetectChefCap

func CreateDetectChefCapResponse 

func CreateDetectChefCapResponse() (response *DetectChefCapResponse)

CreateDetectChefCapResponse creates a response to parse from DetectChefCap response

type DetectFaceRequest 

type DetectFaceRequest struct {
	*requests.RpcRequest
	MaxFaceNumber      requests.Integer `position:"Body" name:"MaxFaceNumber"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Landmark           requests.Boolean `position:"Body" name:"Landmark"`
	OssFile            string           `position:"Query" name:"OssFile"`
	ImageType          requests.Integer `position:"Body" name:"ImageType"`
	Pose               requests.Boolean `position:"Body" name:"Pose"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Quality            requests.Boolean `position:"Body" name:"Quality"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

DetectFaceRequest is the request struct for api DetectFace

func CreateDetectFaceRequest 

func CreateDetectFaceRequest() (request *DetectFaceRequest)

CreateDetectFaceRequest creates a request to invoke DetectFace API

type DetectFaceResponse 

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

DetectFaceResponse is the response struct for api DetectFace

func CreateDetectFaceResponse 

func CreateDetectFaceResponse() (response *DetectFaceResponse)

CreateDetectFaceResponse creates a response to parse from DetectFace response

type DetectIPCPedestrianRequest 

type DetectIPCPedestrianRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	ContinueOnError    requests.Boolean `position:"Body" name:"ContinueOnError"`
	OssFile            string           `position:"Query" name:"OssFile"`
	Height             requests.Integer `position:"Body" name:"Height"`
	ImageData          string           `position:"Body" name:"ImageData"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	DataId             string           `position:"Body" name:"DataId"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
	Width              requests.Integer `position:"Body" name:"Width"`
}

DetectIPCPedestrianRequest is the request struct for api DetectIPCPedestrian

func CreateDetectIPCPedestrianRequest 

func CreateDetectIPCPedestrianRequest() (request *DetectIPCPedestrianRequest)

CreateDetectIPCPedestrianRequest creates a request to invoke DetectIPCPedestrian API

type DetectIPCPedestrianResponse 

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

DetectIPCPedestrianResponse is the response struct for api DetectIPCPedestrian

func CreateDetectIPCPedestrianResponse 

func CreateDetectIPCPedestrianResponse() (response *DetectIPCPedestrianResponse)

CreateDetectIPCPedestrianResponse creates a response to parse from DetectIPCPedestrian response

type DetectLivingFaceRequest 

type DetectLivingFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean         `position:"Query" name:"FormatResultToJson"`
	OssFile            string                   `position:"Query" name:"OssFile"`
	Tasks              *[]DetectLivingFaceTasks `position:"Body" name:"Tasks"  type:"Repeated"`
	RequestProxyBy     string                   `position:"Query" name:"RequestProxyBy"`
}

DetectLivingFaceRequest is the request struct for api DetectLivingFace

func CreateDetectLivingFaceRequest 

func CreateDetectLivingFaceRequest() (request *DetectLivingFaceRequest)

CreateDetectLivingFaceRequest creates a request to invoke DetectLivingFace API

type DetectLivingFaceResponse 

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

DetectLivingFaceResponse is the response struct for api DetectLivingFace

func CreateDetectLivingFaceResponse 

func CreateDetectLivingFaceResponse() (response *DetectLivingFaceResponse)

CreateDetectLivingFaceResponse creates a response to parse from DetectLivingFace response

type DetectLivingFaceTasks 

type DetectLivingFaceTasks struct {
	ImageURL  string `name:"ImageURL"`
	ImageData string `name:"ImageData"`
}

DetectLivingFaceTasks is a repeated param struct in DetectLivingFaceRequest

type DetectPedestrianIntrusionDetectRegion 

type DetectPedestrianIntrusionDetectRegion struct {
	Rect DetectPedestrianIntrusionDetectRegionRect `name:"Rect" type:"Struct"`
	Line DetectPedestrianIntrusionDetectRegionLine `name:"Line" type:"Struct"`
}

DetectPedestrianIntrusionDetectRegion is a repeated param struct in DetectPedestrianIntrusionRequest

type DetectPedestrianIntrusionDetectRegionLine 

type DetectPedestrianIntrusionDetectRegionLine struct {
	Y1 string `name:"Y1"`
	X1 string `name:"X1"`
	Y2 string `name:"Y2"`
	X2 string `name:"X2"`
}

DetectPedestrianIntrusionDetectRegionLine is a repeated param struct in DetectPedestrianIntrusionRequest

type DetectPedestrianIntrusionDetectRegionRect 

type DetectPedestrianIntrusionDetectRegionRect struct {
	Top    string `name:"Top"`
	Left   string `name:"Left"`
	Bottom string `name:"Bottom"`
	Right  string `name:"Right"`
}

DetectPedestrianIntrusionDetectRegionRect is a repeated param struct in DetectPedestrianIntrusionRequest

type DetectPedestrianIntrusionRequest 

type DetectPedestrianIntrusionRequest struct {
	*requests.RpcRequest
	DetectRegion       *[]DetectPedestrianIntrusionDetectRegion `position:"Body" name:"DetectRegion"  type:"Json"`
	RegionType         string                                   `position:"Body" name:"RegionType"`
	FormatResultToJson requests.Boolean                         `position:"Query" name:"FormatResultToJson"`
	OssFile            string                                   `position:"Query" name:"OssFile"`
	RequestProxyBy     string                                   `position:"Query" name:"RequestProxyBy"`
	ImageURL           string                                   `position:"Body" name:"ImageURL"`
}

DetectPedestrianIntrusionRequest is the request struct for api DetectPedestrianIntrusion

func CreateDetectPedestrianIntrusionRequest 

func CreateDetectPedestrianIntrusionRequest() (request *DetectPedestrianIntrusionRequest)

CreateDetectPedestrianIntrusionRequest creates a request to invoke DetectPedestrianIntrusion API

type DetectPedestrianIntrusionResponse 

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

DetectPedestrianIntrusionResponse is the response struct for api DetectPedestrianIntrusion

func CreateDetectPedestrianIntrusionResponse 

func CreateDetectPedestrianIntrusionResponse() (response *DetectPedestrianIntrusionResponse)

CreateDetectPedestrianIntrusionResponse creates a response to parse from DetectPedestrianIntrusion response

type DetectPedestrianRequest 

type DetectPedestrianRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

DetectPedestrianRequest is the request struct for api DetectPedestrian

func CreateDetectPedestrianRequest 

func CreateDetectPedestrianRequest() (request *DetectPedestrianRequest)

CreateDetectPedestrianRequest creates a request to invoke DetectPedestrian API

type DetectPedestrianResponse 

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

DetectPedestrianResponse is the response struct for api DetectPedestrian

func CreateDetectPedestrianResponse 

func CreateDetectPedestrianResponse() (response *DetectPedestrianResponse)

CreateDetectPedestrianResponse creates a response to parse from DetectPedestrian response

type DetectVideoLivingFaceRequest 

type DetectVideoLivingFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	VideoUrl           string           `position:"Body" name:"VideoUrl"`
}

DetectVideoLivingFaceRequest is the request struct for api DetectVideoLivingFace

func CreateDetectVideoLivingFaceRequest 

func CreateDetectVideoLivingFaceRequest() (request *DetectVideoLivingFaceRequest)

CreateDetectVideoLivingFaceRequest creates a request to invoke DetectVideoLivingFace API

type DetectVideoLivingFaceResponse 

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

DetectVideoLivingFaceResponse is the response struct for api DetectVideoLivingFace

func CreateDetectVideoLivingFaceResponse 

func CreateDetectVideoLivingFaceResponse() (response *DetectVideoLivingFaceResponse)

CreateDetectVideoLivingFaceResponse creates a response to parse from DetectVideoLivingFace response

type EarPhone 

type EarPhone struct {
	Score     float64 `json:"Score" xml:"Score"`
	Threshold float64 `json:"Threshold" xml:"Threshold"`
}

EarPhone is a nested struct in facebody response

type Element 

type Element struct {
	FaceConfidence  float64       `json:"FaceConfidence" xml:"FaceConfidence"`
	LiveConfidence  float64       `json:"LiveConfidence" xml:"LiveConfidence"`
	Score           float64       `json:"Score" xml:"Score"`
	FaceNumber      int64         `json:"FaceNumber" xml:"FaceNumber"`
	TaskId          string        `json:"TaskId" xml:"TaskId"`
	ImageURL        string        `json:"ImageURL" xml:"ImageURL"`
	Expression      string        `json:"Expression" xml:"Expression"`
	FaceProbability float64       `json:"FaceProbability" xml:"FaceProbability"`
	Type            string        `json:"Type" xml:"Type"`
	Boxes           []int         `json:"Boxes" xml:"Boxes"`
	Rect            []int         `json:"Rect" xml:"Rect"`
	FaceRectangle   FaceRectangle `json:"FaceRectangle" xml:"FaceRectangle"`
	Results         []Result      `json:"Results" xml:"Results"`
}

Element is a nested struct in facebody response

type ElementInRecognizeAction 

type ElementInRecognizeAction struct {
	Timestamp int         `json:"Timestamp" xml:"Timestamp"`
	Scores    []float64   `json:"Scores" xml:"Scores"`
	Labels    []string    `json:"Labels" xml:"Labels"`
	Boxes     []BoxesItem `json:"Boxes" xml:"Boxes"`
}

ElementInRecognizeAction is a nested struct in facebody response

type ElementsInDetectChefCap 

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

ElementsInDetectChefCap is a nested struct in facebody response

type ElementsInDetectIPCPedestrian 

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

ElementsInDetectIPCPedestrian is a nested struct in facebody response

type ElementsInDetectLivingFace 

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

ElementsInDetectLivingFace is a nested struct in facebody response

type ElementsInDetectPedestrian 

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

ElementsInDetectPedestrian is a nested struct in facebody response

type ElementsInDetectPedestrianIntrusion 

type ElementsInDetectPedestrianIntrusion struct {
	ElementsItem []ElementsItemInDetectPedestrianIntrusion `json:"Elements" xml:"Elements"`
}

ElementsInDetectPedestrianIntrusion is a nested struct in facebody response

type ElementsInDetectVideoLivingFace 

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

ElementsInDetectVideoLivingFace is a nested struct in facebody response

type ElementsInQueryFaceImageTemplate 

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

ElementsInQueryFaceImageTemplate is a nested struct in facebody response

type ElementsInRecognizeAction 

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

ElementsInRecognizeAction is a nested struct in facebody response

type ElementsInRecognizeExpression 

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

ElementsInRecognizeExpression is a nested struct in facebody response

type ElementsInRecognizePublicFace 

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

ElementsInRecognizePublicFace is a nested struct in facebody response

type ElementsItem 

type ElementsItem struct {
	Category    string    `json:"Category" xml:"Category"`
	TemplateId  string    `json:"TemplateId" xml:"TemplateId"`
	TemplateURL string    `json:"TemplateURL" xml:"TemplateURL"`
	UpdateTime  string    `json:"UpdateTime" xml:"UpdateTime"`
	Confidence  float64   `json:"Confidence" xml:"Confidence"`
	UserId      string    `json:"UserId" xml:"UserId"`
	CreateTime  string    `json:"CreateTime" xml:"CreateTime"`
	Box         []float64 `json:"Box" xml:"Box"`
}

ElementsItem is a nested struct in facebody response

type ElementsItemInDetectPedestrianIntrusion 

type ElementsItemInDetectPedestrianIntrusion struct {
	Score     int64  `json:"Score" xml:"Score"`
	Type      string `json:"Type" xml:"Type"`
	IsIntrude bool   `json:"IsIntrude" xml:"IsIntrude"`
	BoxId     int64  `json:"BoxId" xml:"BoxId"`
	Box       Box    `json:"Box" xml:"Box"`
}

ElementsItemInDetectPedestrianIntrusion is a nested struct in facebody response

type EnhanceFaceRequest 

type EnhanceFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

EnhanceFaceRequest is the request struct for api EnhanceFace

func CreateEnhanceFaceRequest 

func CreateEnhanceFaceRequest() (request *EnhanceFaceRequest)

CreateEnhanceFaceRequest creates a request to invoke EnhanceFace API

type EnhanceFaceResponse 

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

EnhanceFaceResponse is the response struct for api EnhanceFace

func CreateEnhanceFaceResponse 

func CreateEnhanceFaceResponse() (response *EnhanceFaceResponse)

CreateEnhanceFaceResponse creates a response to parse from EnhanceFace response

type Entities 

type Entities struct {
	Entity []Entity `json:"Entity" xml:"Entity"`
}

Entities is a nested struct in facebody response

type Entity 

type Entity struct {
	DbName    string `json:"DbName" xml:"DbName"`
	EntityId  string `json:"EntityId" xml:"EntityId"`
	Labels    string `json:"Labels" xml:"Labels"`
	CreatedAt int64  `json:"CreatedAt" xml:"CreatedAt"`
	FaceCount int    `json:"FaceCount" xml:"FaceCount"`
	UpdatedAt int64  `json:"UpdatedAt" xml:"UpdatedAt"`
}

Entity is a nested struct in facebody response

type Expressions 

type Expressions struct {
	Expression []int `json:"Expression" xml:"Expression"`
}

Expressions is a nested struct in facebody response

type ExtractFingerPrintRequest 

type ExtractFingerPrintRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	ImageData          string           `position:"Body" name:"ImageData"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

ExtractFingerPrintRequest is the request struct for api ExtractFingerPrint

func CreateExtractFingerPrintRequest 

func CreateExtractFingerPrintRequest() (request *ExtractFingerPrintRequest)

CreateExtractFingerPrintRequest creates a request to invoke ExtractFingerPrint API

type ExtractFingerPrintResponse 

type ExtractFingerPrintResponse 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"`
}

ExtractFingerPrintResponse is the response struct for api ExtractFingerPrint

func CreateExtractFingerPrintResponse 

func CreateExtractFingerPrintResponse() (response *ExtractFingerPrintResponse)

CreateExtractFingerPrintResponse creates a response to parse from ExtractFingerPrint response

type ExtractPedestrianFeatureAttrRequest 

type ExtractPedestrianFeatureAttrRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Mode               string           `position:"Body" name:"Mode"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
	ServiceVersion     string           `position:"Body" name:"ServiceVersion"`
}

ExtractPedestrianFeatureAttrRequest is the request struct for api ExtractPedestrianFeatureAttr

func CreateExtractPedestrianFeatureAttrRequest 

func CreateExtractPedestrianFeatureAttrRequest() (request *ExtractPedestrianFeatureAttrRequest)

CreateExtractPedestrianFeatureAttrRequest creates a request to invoke ExtractPedestrianFeatureAttr API

type ExtractPedestrianFeatureAttrResponse 

type ExtractPedestrianFeatureAttrResponse 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"`
}

ExtractPedestrianFeatureAttrResponse is the response struct for api ExtractPedestrianFeatureAttr

func CreateExtractPedestrianFeatureAttrResponse 

func CreateExtractPedestrianFeatureAttrResponse() (response *ExtractPedestrianFeatureAttrResponse)

CreateExtractPedestrianFeatureAttrResponse creates a response to parse from ExtractPedestrianFeatureAttr response

type Face 

type Face struct {
	Name   string  `json:"Name" xml:"Name"`
	Rate   float64 `json:"Rate" xml:"Rate"`
	FaceId string  `json:"FaceId" xml:"FaceId"`
	Id     string  `json:"Id" xml:"Id"`
}

Face is a nested struct in facebody response

type FaceBeautyRequest 

type FaceBeautyRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	White              requests.Float   `position:"Body" name:"White"`
	OssFile            string           `position:"Query" name:"OssFile"`
	Smooth             requests.Float   `position:"Body" name:"Smooth"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Sharp              requests.Float   `position:"Body" name:"Sharp"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

FaceBeautyRequest is the request struct for api FaceBeauty

func CreateFaceBeautyRequest 

func CreateFaceBeautyRequest() (request *FaceBeautyRequest)

CreateFaceBeautyRequest creates a request to invoke FaceBeauty API

type FaceBeautyResponse 

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

FaceBeautyResponse is the response struct for api FaceBeauty

func CreateFaceBeautyResponse 

func CreateFaceBeautyResponse() (response *FaceBeautyResponse)

CreateFaceBeautyResponse creates a response to parse from FaceBeauty response

type FaceBoxes 

type FaceBoxes struct {
	FaceBox []float64 `json:"FaceBox" xml:"FaceBox"`
}

FaceBoxes is a nested struct in facebody response

type FaceFilterRequest 

type FaceFilterRequest struct {
	*requests.RpcRequest
	Strength           requests.Float   `position:"Body" name:"Strength"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	ResourceType       string           `position:"Body" name:"ResourceType"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

FaceFilterRequest is the request struct for api FaceFilter

func CreateFaceFilterRequest 

func CreateFaceFilterRequest() (request *FaceFilterRequest)

CreateFaceFilterRequest creates a request to invoke FaceFilter API

type FaceFilterResponse 

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

FaceFilterResponse is the response struct for api FaceFilter

func CreateFaceFilterResponse 

func CreateFaceFilterResponse() (response *FaceFilterResponse)

CreateFaceFilterResponse creates a response to parse from FaceFilter response

type FaceInfo 

type FaceInfo struct {
	Completeness float64 `json:"Completeness" xml:"Completeness"`
	FaceNumber   int64   `json:"FaceNumber" xml:"FaceNumber"`
	Pose         Pose    `json:"Pose" xml:"Pose"`
}

FaceInfo is a nested struct in facebody response

type FaceItems 

type FaceItems struct {
	FaceItemsItem []FaceItemsItem `json:"FaceItems" xml:"FaceItems"`
}

FaceItems is a nested struct in facebody response

type FaceItemsItem 

type FaceItemsItem struct {
	EntityId   string  `json:"EntityId" xml:"EntityId"`
	FaceId     string  `json:"FaceId" xml:"FaceId"`
	Score      float64 `json:"Score" xml:"Score"`
	ExtraData  string  `json:"ExtraData" xml:"ExtraData"`
	DbName     string  `json:"DbName" xml:"DbName"`
	Confidence float64 `json:"Confidence" xml:"Confidence"`
}

FaceItemsItem is a nested struct in facebody response

type FaceMakeupRequest 

type FaceMakeupRequest struct {
	*requests.RpcRequest
	Strength           requests.Float   `position:"Body" name:"Strength"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	MakeupType         string           `position:"Body" name:"MakeupType"`
	ResourceType       string           `position:"Body" name:"ResourceType"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

FaceMakeupRequest is the request struct for api FaceMakeup

func CreateFaceMakeupRequest 

func CreateFaceMakeupRequest() (request *FaceMakeupRequest)

CreateFaceMakeupRequest creates a request to invoke FaceMakeup API

type FaceMakeupResponse 

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

FaceMakeupResponse is the response struct for api FaceMakeup

func CreateFaceMakeupResponse 

func CreateFaceMakeupResponse() (response *FaceMakeupResponse)

CreateFaceMakeupResponse creates a response to parse from FaceMakeup response

type FaceProbabilityListInDetectFace 

type FaceProbabilityListInDetectFace struct {
	FaceProbability []float64 `json:"FaceProbability" xml:"FaceProbability"`
}

FaceProbabilityListInDetectFace is a nested struct in facebody response

type FaceProbabilityListInRecognizeFace 

type FaceProbabilityListInRecognizeFace struct {
	FaceProbability []float64 `json:"FaceProbability" xml:"FaceProbability"`
}

FaceProbabilityListInRecognizeFace is a nested struct in facebody response

type FaceRecognizeResult 

type FaceRecognizeResult struct {
	Name      string    `json:"Name" xml:"Name"`
	FaceBoxes []float64 `json:"FaceBoxes" xml:"FaceBoxes"`
}

FaceRecognizeResult is a nested struct in facebody response

type FaceRecognizeResults 

type FaceRecognizeResults struct {
	FaceRecognizeResult []FaceRecognizeResult `json:"FaceRecognizeResult" xml:"FaceRecognizeResult"`
}

FaceRecognizeResults is a nested struct in facebody response

type FaceRectangle 

type FaceRectangle struct {
	Top    int `json:"Top" xml:"Top"`
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
	Left   int `json:"Left" xml:"Left"`
}

FaceRectangle is a nested struct in facebody response

type FaceRectanglesInDetectFace 

type FaceRectanglesInDetectFace struct {
	FaceRectangle []int `json:"FaceRectangle" xml:"FaceRectangle"`
}

FaceRectanglesInDetectFace is a nested struct in facebody response

type FaceRectanglesInRecognizeFace 

type FaceRectanglesInRecognizeFace struct {
	FaceRectangle []int `json:"FaceRectangle" xml:"FaceRectangle"`
}

FaceRectanglesInRecognizeFace is a nested struct in facebody response

type FaceTidyupRequest 

type FaceTidyupRequest struct {
	*requests.RpcRequest
	ShapeType          requests.Integer `position:"Body" name:"ShapeType"`
	Strength           requests.Float   `position:"Body" name:"Strength"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

FaceTidyupRequest is the request struct for api FaceTidyup

func CreateFaceTidyupRequest 

func CreateFaceTidyupRequest() (request *FaceTidyupRequest)

CreateFaceTidyupRequest creates a request to invoke FaceTidyup API

type FaceTidyupResponse 

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

FaceTidyupResponse is the response struct for api FaceTidyup

func CreateFaceTidyupResponse 

func CreateFaceTidyupResponse() (response *FaceTidyupResponse)

CreateFaceTidyupResponse creates a response to parse from FaceTidyup response

type FacesInGetFaceEntity 

type FacesInGetFaceEntity struct {
	Face []Face `json:"Face" xml:"Face"`
}

FacesInGetFaceEntity is a nested struct in facebody response

type FacesInRecognizePublicFace 

type FacesInRecognizePublicFace struct {
	Face []Face `json:"Face" xml:"Face"`
}

FacesInRecognizePublicFace is a nested struct in facebody response

type FailedFaces 

type FailedFaces struct {
	FailedFacesItem []FailedFacesItem `json:"failedFaces" xml:"failedFaces"`
}

FailedFaces is a nested struct in facebody response

type FailedFacesItem 

type FailedFacesItem struct {
	ImageURL string `json:"ImageURL" xml:"ImageURL"`
	Code     string `json:"Code" xml:"Code"`
	Message  string `json:"Message" xml:"Message"`
}

FailedFacesItem is a nested struct in facebody response

type FnfListInDetectFace 

type FnfListInDetectFace struct {
	Fnf []float64 `json:"Fnf" xml:"Fnf"`
}

FnfListInDetectFace is a nested struct in facebody response

type FnfListInRecognizeFace 

type FnfListInRecognizeFace struct {
	Fnf []float64 `json:"Fnf" xml:"Fnf"`
}

FnfListInRecognizeFace is a nested struct in facebody response

type Frame 

type Frame struct {
	Url  string  `json:"Url" xml:"Url"`
	Rate float64 `json:"Rate" xml:"Rate"`
}

Frame is a nested struct in facebody response

type Frames 

type Frames struct {
	Frame []Frame `json:"Frame" xml:"Frame"`
}

Frames is a nested struct in facebody response

type GenRealPersonVerificationTokenRequest 

type GenRealPersonVerificationTokenRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	MetaInfo           string           `position:"Body" name:"MetaInfo"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	CertificateNumber  string           `position:"Body" name:"CertificateNumber"`
	CertificateName    string           `position:"Body" name:"CertificateName"`
}

GenRealPersonVerificationTokenRequest is the request struct for api GenRealPersonVerificationToken

func CreateGenRealPersonVerificationTokenRequest 

func CreateGenRealPersonVerificationTokenRequest() (request *GenRealPersonVerificationTokenRequest)

CreateGenRealPersonVerificationTokenRequest creates a request to invoke GenRealPersonVerificationToken API

type GenRealPersonVerificationTokenResponse 

type GenRealPersonVerificationTokenResponse struct {
	*responses.BaseResponse
	RequestId    string `json:"RequestId" xml:"RequestId"`
	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
	Code         string `json:"Code" xml:"Code"`
	Success      bool   `json:"Success" xml:"Success"`
	Data         Data   `json:"Data" xml:"Data"`
}

GenRealPersonVerificationTokenResponse is the response struct for api GenRealPersonVerificationToken

func CreateGenRealPersonVerificationTokenResponse 

func CreateGenRealPersonVerificationTokenResponse() (response *GenRealPersonVerificationTokenResponse)

CreateGenRealPersonVerificationTokenResponse creates a response to parse from GenRealPersonVerificationToken response

type Gender 

type Gender struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Gender is a nested struct in facebody response

type GenderList 

type GenderList struct {
	Gender []int `json:"Gender" xml:"Gender"`
}

GenderList is a nested struct in facebody response

type GenerateHumanAnimeStyleRequest 

type GenerateHumanAnimeStyleRequest struct {
	*requests.RpcRequest
	AlgoType           string           `position:"Query" name:"AlgoType"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Query" name:"ImageURL"`
}

GenerateHumanAnimeStyleRequest is the request struct for api GenerateHumanAnimeStyle

func CreateGenerateHumanAnimeStyleRequest 

func CreateGenerateHumanAnimeStyleRequest() (request *GenerateHumanAnimeStyleRequest)

CreateGenerateHumanAnimeStyleRequest creates a request to invoke GenerateHumanAnimeStyle API

type GenerateHumanAnimeStyleResponse 

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

GenerateHumanAnimeStyleResponse is the response struct for api GenerateHumanAnimeStyle

func CreateGenerateHumanAnimeStyleResponse 

func CreateGenerateHumanAnimeStyleResponse() (response *GenerateHumanAnimeStyleResponse)

CreateGenerateHumanAnimeStyleResponse creates a response to parse from GenerateHumanAnimeStyle response

type GenerateHumanSketchStyleRequest 

type GenerateHumanSketchStyleRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	ReturnType         string           `position:"Body" name:"ReturnType"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

GenerateHumanSketchStyleRequest is the request struct for api GenerateHumanSketchStyle

func CreateGenerateHumanSketchStyleRequest 

func CreateGenerateHumanSketchStyleRequest() (request *GenerateHumanSketchStyleRequest)

CreateGenerateHumanSketchStyleRequest creates a request to invoke GenerateHumanSketchStyle API

type GenerateHumanSketchStyleResponse 

type GenerateHumanSketchStyleResponse 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"`
}

GenerateHumanSketchStyleResponse is the response struct for api GenerateHumanSketchStyle

func CreateGenerateHumanSketchStyleResponse 

func CreateGenerateHumanSketchStyleResponse() (response *GenerateHumanSketchStyleResponse)

CreateGenerateHumanSketchStyleResponse creates a response to parse from GenerateHumanSketchStyle response

type GetFaceEntityRequest 

type GetFaceEntityRequest struct {
	*requests.RpcRequest
	EntityId           string           `position:"Body" name:"EntityId"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	DbName             string           `position:"Body" name:"DbName"`
}

GetFaceEntityRequest is the request struct for api GetFaceEntity

func CreateGetFaceEntityRequest 

func CreateGetFaceEntityRequest() (request *GetFaceEntityRequest)

CreateGetFaceEntityRequest creates a request to invoke GetFaceEntity API

type GetFaceEntityResponse 

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

GetFaceEntityResponse is the response struct for api GetFaceEntity

func CreateGetFaceEntityResponse 

func CreateGetFaceEntityResponse() (response *GetFaceEntityResponse)

CreateGetFaceEntityResponse creates a response to parse from GetFaceEntity response

type GetRealPersonVerificationResultRequest 

type GetRealPersonVerificationResultRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	MaterialHash       string           `position:"Body" name:"MaterialHash"`
	OssFile            string           `position:"Query" name:"OssFile"`
	VerificationToken  string           `position:"Body" name:"VerificationToken"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
}

GetRealPersonVerificationResultRequest is the request struct for api GetRealPersonVerificationResult

func CreateGetRealPersonVerificationResultRequest 

func CreateGetRealPersonVerificationResultRequest() (request *GetRealPersonVerificationResultRequest)

CreateGetRealPersonVerificationResultRequest creates a request to invoke GetRealPersonVerificationResult API

type GetRealPersonVerificationResultResponse 

type GetRealPersonVerificationResultResponse struct {
	*responses.BaseResponse
	RequestId    string `json:"RequestId" xml:"RequestId"`
	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
	Code         string `json:"Code" xml:"Code"`
	Success      bool   `json:"Success" xml:"Success"`
	Data         Data   `json:"Data" xml:"Data"`
}

GetRealPersonVerificationResultResponse is the response struct for api GetRealPersonVerificationResult

func CreateGetRealPersonVerificationResultResponse 

func CreateGetRealPersonVerificationResultResponse() (response *GetRealPersonVerificationResultResponse)

CreateGetRealPersonVerificationResultResponse creates a response to parse from GetRealPersonVerificationResult response

type GlassListInDetectFace 

type GlassListInDetectFace struct {
	Glass []float64 `json:"Glass" xml:"Glass"`
}

GlassListInDetectFace is a nested struct in facebody response

type GlassListInRecognizeFace 

type GlassListInRecognizeFace struct {
	Glass []float64 `json:"Glass" xml:"Glass"`
}

GlassListInRecognizeFace is a nested struct in facebody response

type Glasses 

type Glasses struct {
	Name  string  `json:"Name" xml:"Name"`
	Score float64 `json:"Score" xml:"Score"`
}

Glasses is a nested struct in facebody response

type GlassesInRecognizeFace 

type GlassesInRecognizeFace struct {
	Glass []int `json:"Glass" xml:"Glass"`
}

GlassesInRecognizeFace is a nested struct in facebody response

type HandPostureRequest 

type HandPostureRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

HandPostureRequest is the request struct for api HandPosture

func CreateHandPostureRequest 

func CreateHandPostureRequest() (request *HandPostureRequest)

CreateHandPostureRequest creates a request to invoke HandPosture API

type HandPostureResponse 

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

HandPostureResponse is the response struct for api HandPosture

func CreateHandPostureResponse 

func CreateHandPostureResponse() (response *HandPostureResponse)

CreateHandPostureResponse creates a response to parse from HandPosture response

type Handbag 

type Handbag struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Handbag is a nested struct in facebody response

type Hands 

type Hands struct {
	Confident float64    `json:"Confident" xml:"Confident"`
	KeyPoints []KeyPoint `json:"KeyPoints" xml:"KeyPoints"`
}

Hands is a nested struct in facebody response

type Hat 

type Hat struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Hat is a nested struct in facebody response

type HatList 

type HatList struct {
	Hat []int `json:"Hat" xml:"Hat"`
}

HatList is a nested struct in facebody response

type IlluListInDetectFace 

type IlluListInDetectFace struct {
	Illu []float64 `json:"Illu" xml:"Illu"`
}

IlluListInDetectFace is a nested struct in facebody response

type IlluListInRecognizeFace 

type IlluListInRecognizeFace struct {
	Illu []float64 `json:"Illu" xml:"Illu"`
}

IlluListInRecognizeFace is a nested struct in facebody response

type ImageInfoList 

type ImageInfoList struct {
	ImageInfoListItem []ImageInfoListItem `json:"ImageInfoList" xml:"ImageInfoList"`
}

ImageInfoList is a nested struct in facebody response

type ImageInfoListItem 

type ImageInfoListItem struct {
	ErrorMessage string    `json:"ErrorMessage" xml:"ErrorMessage"`
	ErrorCode    string    `json:"ErrorCode" xml:"ErrorCode"`
	DataId       string    `json:"DataId" xml:"DataId"`
	Elements     []Element `json:"Elements" xml:"Elements"`
}

ImageInfoListItem is a nested struct in facebody response

type InsertedFaces 

type InsertedFaces struct {
	InsertedFacesItem []InsertedFacesItem `json:"insertedFaces" xml:"insertedFaces"`
}

InsertedFaces is a nested struct in facebody response

type InsertedFacesItem 

type InsertedFacesItem struct {
	ImageURL      string  `json:"ImageURL" xml:"ImageURL"`
	FaceId        string  `json:"FaceId" xml:"FaceId"`
	QualitieScore float64 `json:"QualitieScore" xml:"QualitieScore"`
}

InsertedFacesItem is a nested struct in facebody response

type KeyPoint 

type KeyPoint struct {
	Label     string     `json:"Label" xml:"Label"`
	Positions []Position `json:"Positions" xml:"Positions"`
}

KeyPoint is a nested struct in facebody response

type KeyPoints 

type KeyPoints struct {
	KeyPoint []KeyPoint `json:"KeyPoint" xml:"KeyPoint"`
}

KeyPoints is a nested struct in facebody response

type Labels 

type Labels struct {
	Label []string `json:"Label" xml:"Label"`
}

Labels is a nested struct in facebody response

type LandmarksAList 

type LandmarksAList struct {
	LandmarksAList []int64 `json:"landmarksAList" xml:"landmarksAList"`
}

LandmarksAList is a nested struct in facebody response

type LandmarksBList 

type LandmarksBList struct {
	LandmarksBList []int64 `json:"landmarksBList" xml:"landmarksBList"`
}

LandmarksBList is a nested struct in facebody response

type LandmarksInDetectFace 

type LandmarksInDetectFace struct {
	Landmark []float64 `json:"Landmark" xml:"Landmark"`
}

LandmarksInDetectFace is a nested struct in facebody response

type LandmarksInRecognizeFace 

type LandmarksInRecognizeFace struct {
	Landmark []float64 `json:"Landmark" xml:"Landmark"`
}

LandmarksInRecognizeFace is a nested struct in facebody response

type LiquifyFaceRequest 

type LiquifyFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	SlimDegree         requests.Float   `position:"Body" name:"SlimDegree"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

LiquifyFaceRequest is the request struct for api LiquifyFace

func CreateLiquifyFaceRequest 

func CreateLiquifyFaceRequest() (request *LiquifyFaceRequest)

CreateLiquifyFaceRequest creates a request to invoke LiquifyFace API

type LiquifyFaceResponse 

type LiquifyFaceResponse 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"`
}

LiquifyFaceResponse is the response struct for api LiquifyFace

func CreateLiquifyFaceResponse 

func CreateLiquifyFaceResponse() (response *LiquifyFaceResponse)

CreateLiquifyFaceResponse creates a response to parse from LiquifyFace response

type ListFaceDbsRequest 

type ListFaceDbsRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Limit              requests.Integer `position:"Body" name:"Limit"`
	OssFile            string           `position:"Query" name:"OssFile"`
	Offset             requests.Integer `position:"Body" name:"Offset"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
}

ListFaceDbsRequest is the request struct for api ListFaceDbs

func CreateListFaceDbsRequest 

func CreateListFaceDbsRequest() (request *ListFaceDbsRequest)

CreateListFaceDbsRequest creates a request to invoke ListFaceDbs API

type ListFaceDbsResponse 

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

ListFaceDbsResponse is the response struct for api ListFaceDbs

func CreateListFaceDbsResponse 

func CreateListFaceDbsResponse() (response *ListFaceDbsResponse)

CreateListFaceDbsResponse creates a response to parse from ListFaceDbs response

type ListFaceEntitiesRequest 

type ListFaceEntitiesRequest struct {
	*requests.RpcRequest
	EntityIdPrefix     string           `position:"Body" name:"EntityIdPrefix"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Limit              requests.Integer `position:"Body" name:"Limit"`
	OssFile            string           `position:"Query" name:"OssFile"`
	Order              string           `position:"Body" name:"Order"`
	Offset             requests.Integer `position:"Body" name:"Offset"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Token              string           `position:"Body" name:"Token"`
	Labels             string           `position:"Body" name:"Labels"`
	DbName             string           `position:"Body" name:"DbName"`
}

ListFaceEntitiesRequest is the request struct for api ListFaceEntities

func CreateListFaceEntitiesRequest 

func CreateListFaceEntitiesRequest() (request *ListFaceEntitiesRequest)

CreateListFaceEntitiesRequest creates a request to invoke ListFaceEntities API

type ListFaceEntitiesResponse 

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

ListFaceEntitiesResponse is the response struct for api ListFaceEntities

func CreateListFaceEntitiesResponse 

func CreateListFaceEntitiesResponse() (response *ListFaceEntitiesResponse)

CreateListFaceEntitiesResponse creates a response to parse from ListFaceEntities response

type Location 

type Location 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"`
}

Location is a nested struct in facebody response

type LowerColor 

type LowerColor struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

LowerColor is a nested struct in facebody response

type LowerWear 

type LowerWear struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

LowerWear is a nested struct in facebody response

type MaskListInDetectFace 

type MaskListInDetectFace struct {
	Mask []float64 `json:"Mask" xml:"Mask"`
}

MaskListInDetectFace is a nested struct in facebody response

type MaskListInRecognizeFace 

type MaskListInRecognizeFace struct {
	Mask []float64 `json:"Mask" xml:"Mask"`
}

MaskListInRecognizeFace is a nested struct in facebody response

type Masks 

type Masks struct {
	Mask []int64 `json:"Mask" xml:"Mask"`
}

Masks is a nested struct in facebody response

type MatchList 

type MatchList struct {
	MatchListItem []MatchListItem `json:"MatchList" xml:"MatchList"`
}

MatchList is a nested struct in facebody response

type MatchListItem 

type MatchListItem struct {
	QualitieScore float64         `json:"QualitieScore" xml:"QualitieScore"`
	Location      Location        `json:"Location" xml:"Location"`
	FaceItems     []FaceItemsItem `json:"FaceItems" xml:"FaceItems"`
}

MatchListItem is a nested struct in facebody response

type MergeImageFaceRequest 

type MergeImageFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	UserId             string           `position:"Body" name:"UserId"`
	OssFile            string           `position:"Query" name:"OssFile"`
	TemplateId         string           `position:"Body" name:"TemplateId"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

MergeImageFaceRequest is the request struct for api MergeImageFace

func CreateMergeImageFaceRequest 

func CreateMergeImageFaceRequest() (request *MergeImageFaceRequest)

CreateMergeImageFaceRequest creates a request to invoke MergeImageFace API

type MergeImageFaceResponse 

type MergeImageFaceResponse 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"`
}

MergeImageFaceResponse is the response struct for api MergeImageFace

func CreateMergeImageFaceResponse 

func CreateMergeImageFaceResponse() (response *MergeImageFaceResponse)

CreateMergeImageFaceResponse creates a response to parse from MergeImageFace response

type MetaObject 

type MetaObject struct {
	Width  int `json:"Width" xml:"Width"`
	Height int `json:"Height" xml:"Height"`
}

MetaObject is a nested struct in facebody response

type MonitorExaminationRequest 

type MonitorExaminationRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Type               requests.Integer `position:"Body" name:"Type"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

MonitorExaminationRequest is the request struct for api MonitorExamination

func CreateMonitorExaminationRequest 

func CreateMonitorExaminationRequest() (request *MonitorExaminationRequest)

CreateMonitorExaminationRequest creates a request to invoke MonitorExamination API

type MonitorExaminationResponse 

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

MonitorExaminationResponse is the response struct for api MonitorExamination

func CreateMonitorExaminationResponse 

func CreateMonitorExaminationResponse() (response *MonitorExaminationResponse)

CreateMonitorExaminationResponse creates a response to parse from MonitorExamination response

type NoiseListInDetectFace 

type NoiseListInDetectFace struct {
	Noise []float64 `json:"Noise" xml:"Noise"`
}

NoiseListInDetectFace is a nested struct in facebody response

type NoiseListInRecognizeFace 

type NoiseListInRecognizeFace struct {
	Noise []float64 `json:"Noise" xml:"Noise"`
}

NoiseListInRecognizeFace is a nested struct in facebody response

type Orient 

type Orient struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

Orient is a nested struct in facebody response

type Output 

type Output struct {
	HumanCount int      `json:"HumanCount" xml:"HumanCount"`
	HandCount  int      `json:"HandCount" xml:"HandCount"`
	Results    []Result `json:"Results" xml:"Results"`
}

Output is a nested struct in facebody response

type OutputsInBodyPosture 

type OutputsInBodyPosture struct {
	Output []Output `json:"Output" xml:"Output"`
}

OutputsInBodyPosture is a nested struct in facebody response

type OutputsInHandPosture 

type OutputsInHandPosture struct {
	Output []Output `json:"Output" xml:"Output"`
}

OutputsInHandPosture is a nested struct in facebody response

type PedestrianDetectAttributeRequest 

type PedestrianDetectAttributeRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

PedestrianDetectAttributeRequest is the request struct for api PedestrianDetectAttribute

func CreatePedestrianDetectAttributeRequest 

func CreatePedestrianDetectAttributeRequest() (request *PedestrianDetectAttributeRequest)

CreatePedestrianDetectAttributeRequest creates a request to invoke PedestrianDetectAttribute API

type PedestrianDetectAttributeResponse 

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

PedestrianDetectAttributeResponse is the response struct for api PedestrianDetectAttribute

func CreatePedestrianDetectAttributeResponse 

func CreatePedestrianDetectAttributeResponse() (response *PedestrianDetectAttributeResponse)

CreatePedestrianDetectAttributeResponse creates a response to parse from PedestrianDetectAttribute response

type PersonInfo 

type PersonInfo struct {
	PersonNumber int64     `json:"PersonNumber" xml:"PersonNumber"`
	CellPhone    CellPhone `json:"CellPhone" xml:"CellPhone"`
	EarPhone     EarPhone  `json:"EarPhone" xml:"EarPhone"`
}

PersonInfo is a nested struct in facebody response

type PointsInBodyPosture 

type PointsInBodyPosture struct {
	Point []float64 `json:"Point" xml:"Point"`
}

PointsInBodyPosture is a nested struct in facebody response

type PointsInHandPosture 

type PointsInHandPosture struct {
	Point []float64 `json:"Point" xml:"Point"`
}

PointsInHandPosture is a nested struct in facebody response

type Pose 

type Pose struct {
	Pitch float64 `json:"Pitch" xml:"Pitch"`
	Roll  float64 `json:"Roll" xml:"Roll"`
	Yaw   float64 `json:"Yaw" xml:"Yaw"`
}

Pose is a nested struct in facebody response

type PoseListInDetectFace 

type PoseListInDetectFace struct {
	Pose []float64 `json:"Pose" xml:"Pose"`
}

PoseListInDetectFace is a nested struct in facebody response

type PoseListInRecognizeFace 

type PoseListInRecognizeFace struct {
	Pose []float64 `json:"Pose" xml:"Pose"`
}

PoseListInRecognizeFace is a nested struct in facebody response

type Position 

type Position struct {
	Points []float64 `json:"Points" xml:"Points"`
}

Position is a nested struct in facebody response

type PositionsInBodyPosture 

type PositionsInBodyPosture struct {
	Position []Position `json:"Position" xml:"Position"`
}

PositionsInBodyPosture is a nested struct in facebody response

type PositionsInHandPosture 

type PositionsInHandPosture struct {
	Position []Position `json:"Position" xml:"Position"`
}

PositionsInHandPosture is a nested struct in facebody response

type PupilsInDetectFace 

type PupilsInDetectFace struct {
	Pupil []float64 `json:"Pupil" xml:"Pupil"`
}

PupilsInDetectFace is a nested struct in facebody response

type PupilsInRecognizeFace 

type PupilsInRecognizeFace struct {
	Pupil []float64 `json:"Pupil" xml:"Pupil"`
}

PupilsInRecognizeFace is a nested struct in facebody response

type Qualities 

type Qualities struct {
	MaskList  []float64 `json:"MaskList" xml:"MaskList"`
	FnfList   []float64 `json:"FnfList" xml:"FnfList"`
	IlluList  []float64 `json:"IlluList" xml:"IlluList"`
	NoiseList []float64 `json:"NoiseList" xml:"NoiseList"`
	PoseList  []float64 `json:"PoseList" xml:"PoseList"`
	ScoreList []float64 `json:"ScoreList" xml:"ScoreList"`
	BlurList  []float64 `json:"BlurList" xml:"BlurList"`
	GlassList []float64 `json:"GlassList" xml:"GlassList"`
}

Qualities is a nested struct in facebody response

type QueryFaceImageTemplateRequest 

type QueryFaceImageTemplateRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	UserId             string           `position:"Query" name:"UserId"`
	OssFile            string           `position:"Query" name:"OssFile"`
	TemplateId         string           `position:"Query" name:"TemplateId"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
}

QueryFaceImageTemplateRequest is the request struct for api QueryFaceImageTemplate

func CreateQueryFaceImageTemplateRequest 

func CreateQueryFaceImageTemplateRequest() (request *QueryFaceImageTemplateRequest)

CreateQueryFaceImageTemplateRequest creates a request to invoke QueryFaceImageTemplate API

type QueryFaceImageTemplateResponse 

type QueryFaceImageTemplateResponse 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"`
}

QueryFaceImageTemplateResponse is the response struct for api QueryFaceImageTemplate

func CreateQueryFaceImageTemplateResponse 

func CreateQueryFaceImageTemplateResponse() (response *QueryFaceImageTemplateResponse)

CreateQueryFaceImageTemplateResponse creates a response to parse from QueryFaceImageTemplate response

type RecognizeActionRequest 

type RecognizeActionRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean          `position:"Query" name:"FormatResultToJson"`
	Type               requests.Integer          `position:"Body" name:"Type"`
	OssFile            string                    `position:"Query" name:"OssFile"`
	VideoData          string                    `position:"Body" name:"VideoData"`
	URLList            *[]RecognizeActionURLList `position:"Body" name:"URLList"  type:"Repeated"`
	RequestProxyBy     string                    `position:"Query" name:"RequestProxyBy"`
	VideoUrl           string                    `position:"Body" name:"VideoUrl"`
}

RecognizeActionRequest is the request struct for api RecognizeAction

func CreateRecognizeActionRequest 

func CreateRecognizeActionRequest() (request *RecognizeActionRequest)

CreateRecognizeActionRequest creates a request to invoke RecognizeAction API

type RecognizeActionResponse 

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

RecognizeActionResponse is the response struct for api RecognizeAction

func CreateRecognizeActionResponse 

func CreateRecognizeActionResponse() (response *RecognizeActionResponse)

CreateRecognizeActionResponse creates a response to parse from RecognizeAction response

type RecognizeActionURLList 

type RecognizeActionURLList struct {
	ImageData string `name:"imageData"`
	URL       string `name:"URL"`
}

RecognizeActionURLList is a repeated param struct in RecognizeActionRequest

type RecognizeExpressionRequest 

type RecognizeExpressionRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

RecognizeExpressionRequest is the request struct for api RecognizeExpression

func CreateRecognizeExpressionRequest 

func CreateRecognizeExpressionRequest() (request *RecognizeExpressionRequest)

CreateRecognizeExpressionRequest creates a request to invoke RecognizeExpression API

type RecognizeExpressionResponse 

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

RecognizeExpressionResponse is the response struct for api RecognizeExpression

func CreateRecognizeExpressionResponse 

func CreateRecognizeExpressionResponse() (response *RecognizeExpressionResponse)

CreateRecognizeExpressionResponse creates a response to parse from RecognizeExpression response

type RecognizeFaceRequest 

type RecognizeFaceRequest struct {
	*requests.RpcRequest
	Gender             requests.Boolean `position:"Body" name:"Gender"`
	Beauty             requests.Boolean `position:"Body" name:"Beauty"`
	MaxFaceNumber      requests.Integer `position:"Body" name:"MaxFaceNumber"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	Hat                requests.Boolean `position:"Body" name:"Hat"`
	OssFile            string           `position:"Query" name:"OssFile"`
	Mask               requests.Boolean `position:"Body" name:"Mask"`
	ImageType          requests.Integer `position:"Body" name:"ImageType"`
	Glass              requests.Boolean `position:"Body" name:"Glass"`
	Expression         requests.Boolean `position:"Body" name:"Expression"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Quality            requests.Boolean `position:"Body" name:"Quality"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
	Age                requests.Boolean `position:"Body" name:"Age"`
}

RecognizeFaceRequest is the request struct for api RecognizeFace

func CreateRecognizeFaceRequest 

func CreateRecognizeFaceRequest() (request *RecognizeFaceRequest)

CreateRecognizeFaceRequest creates a request to invoke RecognizeFace API

type RecognizeFaceResponse 

type RecognizeFaceResponse 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"`
}

RecognizeFaceResponse is the response struct for api RecognizeFace

func CreateRecognizeFaceResponse 

func CreateRecognizeFaceResponse() (response *RecognizeFaceResponse)

CreateRecognizeFaceResponse creates a response to parse from RecognizeFace response

type RecognizeHandGestureRequest 

type RecognizeHandGestureRequest struct {
	*requests.RpcRequest
	GestureType        string           `position:"Body" name:"GestureType"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	AppId              string           `position:"Body" name:"AppId"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

RecognizeHandGestureRequest is the request struct for api RecognizeHandGesture

func CreateRecognizeHandGestureRequest 

func CreateRecognizeHandGestureRequest() (request *RecognizeHandGestureRequest)

CreateRecognizeHandGestureRequest creates a request to invoke RecognizeHandGesture API

type RecognizeHandGestureResponse 

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

RecognizeHandGestureResponse is the response struct for api RecognizeHandGesture

func CreateRecognizeHandGestureResponse 

func CreateRecognizeHandGestureResponse() (response *RecognizeHandGestureResponse)

CreateRecognizeHandGestureResponse creates a response to parse from RecognizeHandGesture response

type RecognizePublicFaceRequest 

type RecognizePublicFaceRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean           `position:"Query" name:"FormatResultToJson"`
	OssFile            string                     `position:"Query" name:"OssFile"`
	RequestProxyBy     string                     `position:"Query" name:"RequestProxyBy"`
	Task               *[]RecognizePublicFaceTask `position:"Body" name:"Task"  type:"Repeated"`
}

RecognizePublicFaceRequest is the request struct for api RecognizePublicFace

func CreateRecognizePublicFaceRequest 

func CreateRecognizePublicFaceRequest() (request *RecognizePublicFaceRequest)

CreateRecognizePublicFaceRequest creates a request to invoke RecognizePublicFace API

type RecognizePublicFaceResponse 

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

RecognizePublicFaceResponse is the response struct for api RecognizePublicFace

func CreateRecognizePublicFaceResponse 

func CreateRecognizePublicFaceResponse() (response *RecognizePublicFaceResponse)

CreateRecognizePublicFaceResponse creates a response to parse from RecognizePublicFace response

type RecognizePublicFaceTask 

type RecognizePublicFaceTask struct {
	ImageURL  string `name:"ImageURL"`
	ImageData string `name:"ImageData"`
}

RecognizePublicFaceTask is a repeated param struct in RecognizePublicFaceRequest

type Rect 

type Rect struct {
	Left   int64 `json:"Left" xml:"Left"`
	Width  int64 `json:"Width" xml:"Width"`
	Top    int64 `json:"Top" xml:"Top"`
	Height int64 `json:"Height" xml:"Height"`
}

Rect is a nested struct in facebody response

type RectAList 

type RectAList struct {
	RectA []int `json:"RectA" xml:"RectA"`
}

RectAList is a nested struct in facebody response

type RectBList 

type RectBList struct {
	RectB []int `json:"RectB" xml:"RectB"`
}

RectBList is a nested struct in facebody response

type RectInDetectVideoLivingFace 

type RectInDetectVideoLivingFace struct {
	Result []int `json:"Result" xml:"Result"`
}

RectInDetectVideoLivingFace is a nested struct in facebody response

type Rectangle 

type Rectangle struct {
	Rectangle []int `json:"Rectangle" xml:"Rectangle"`
}

Rectangle is a nested struct in facebody response

type RectangleRef 

type RectangleRef struct {
	RectangleRef []int `json:"RectangleRef" xml:"RectangleRef"`
}

RectangleRef is a nested struct in facebody response

type Result 

type Result struct {
	Rate        float64     `json:"Rate" xml:"Rate"`
	Suggestion  string      `json:"Suggestion" xml:"Suggestion"`
	Label       string      `json:"Label" xml:"Label"`
	MessageTips string      `json:"MessageTips" xml:"MessageTips"`
	Rect        Rect        `json:"Rect" xml:"Rect"`
	Hands       Hands       `json:"Hands" xml:"Hands"`
	Box         Box         `json:"Box" xml:"Box"`
	Bodies      []Body      `json:"Bodies" xml:"Bodies"`
	Frames      []Frame     `json:"Frames" xml:"Frames"`
	SubResults  []SubResult `json:"SubResults" xml:"SubResults"`
}

Result is a nested struct in facebody response

type ResultsInBodyPosture 

type ResultsInBodyPosture struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInBodyPosture is a nested struct in facebody response

type ResultsInDetectLivingFace 

type ResultsInDetectLivingFace struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInDetectLivingFace is a nested struct in facebody response

type ResultsInHandPosture 

type ResultsInHandPosture struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInHandPosture is a nested struct in facebody response

type ResultsInRecognizePublicFace 

type ResultsInRecognizePublicFace struct {
	Result []Result `json:"Result" xml:"Result"`
}

ResultsInRecognizePublicFace is a nested struct in facebody response

type RetouchBodyRequest 

type RetouchBodyRequest struct {
	*requests.RpcRequest
	LengthenDegree     requests.Float   `position:"Body" name:"LengthenDegree"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	SlimDegree         requests.Float   `position:"Body" name:"SlimDegree"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

RetouchBodyRequest is the request struct for api RetouchBody

func CreateRetouchBodyRequest 

func CreateRetouchBodyRequest() (request *RetouchBodyRequest)

CreateRetouchBodyRequest creates a request to invoke RetouchBody API

type RetouchBodyResponse 

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

RetouchBodyResponse is the response struct for api RetouchBody

func CreateRetouchBodyResponse 

func CreateRetouchBodyResponse() (response *RetouchBodyResponse)

CreateRetouchBodyResponse creates a response to parse from RetouchBody response

type RetouchSkinRequest 

type RetouchSkinRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	RetouchDegree      requests.Float   `position:"Body" name:"RetouchDegree"`
	WhiteningDegree    requests.Float   `position:"Body" name:"WhiteningDegree"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
}

RetouchSkinRequest is the request struct for api RetouchSkin

func CreateRetouchSkinRequest 

func CreateRetouchSkinRequest() (request *RetouchSkinRequest)

CreateRetouchSkinRequest creates a request to invoke RetouchSkin API

type RetouchSkinResponse 

type RetouchSkinResponse 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"`
}

RetouchSkinResponse is the response struct for api RetouchSkin

func CreateRetouchSkinResponse 

func CreateRetouchSkinResponse() (response *RetouchSkinResponse)

CreateRetouchSkinResponse creates a response to parse from RetouchSkin response

type ScoreListInDetectFace 

type ScoreListInDetectFace struct {
	Score []float64 `json:"Score" xml:"Score"`
}

ScoreListInDetectFace is a nested struct in facebody response

type ScoreListInRecognizeFace 

type ScoreListInRecognizeFace struct {
	Score []float64 `json:"Score" xml:"Score"`
}

ScoreListInRecognizeFace is a nested struct in facebody response

type Scores 

type Scores struct {
	Score []float64 `json:"Score" xml:"Score"`
}

Scores is a nested struct in facebody response

type SearchFaceRequest 

type SearchFaceRequest struct {
	*requests.RpcRequest
	MaxFaceNum            requests.Integer `position:"Body" name:"MaxFaceNum"`
	FormatResultToJson    requests.Boolean `position:"Query" name:"FormatResultToJson"`
	QualityScoreThreshold requests.Float   `position:"Body" name:"QualityScoreThreshold"`
	Limit                 requests.Integer `position:"Body" name:"Limit"`
	OssFile               string           `position:"Query" name:"OssFile"`
	RequestProxyBy        string           `position:"Query" name:"RequestProxyBy"`
	DbNames               string           `position:"Body" name:"DbNames"`
	DbName                string           `position:"Body" name:"DbName"`
	ImageUrl              string           `position:"Body" name:"ImageUrl"`
}

SearchFaceRequest is the request struct for api SearchFace

func CreateSearchFaceRequest 

func CreateSearchFaceRequest() (request *SearchFaceRequest)

CreateSearchFaceRequest creates a request to invoke SearchFace API

type SearchFaceResponse 

type SearchFaceResponse 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"`
}

SearchFaceResponse is the response struct for api SearchFace

func CreateSearchFaceResponse 

func CreateSearchFaceResponse() (response *SearchFaceResponse)

CreateSearchFaceResponse creates a response to parse from SearchFace response

type ShoulderBag 

type ShoulderBag struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

ShoulderBag is a nested struct in facebody response

type SubResult 

type SubResult struct {
	W     float64 `json:"W" xml:"W"`
	H     float64 `json:"H" xml:"H"`
	Y     float64 `json:"Y" xml:"Y"`
	X     float64 `json:"X" xml:"X"`
	Faces []Face  `json:"Faces" xml:"Faces"`
}

SubResult is a nested struct in facebody response

type SubResults 

type SubResults struct {
	SubResult []SubResult `json:"SubResult" xml:"SubResult"`
}

SubResults is a nested struct in facebody response

type SwapFacialFeaturesRequest 

type SwapFacialFeaturesRequest struct {
	*requests.RpcRequest
	TargetImageURL     string           `position:"Body" name:"TargetImageURL"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	SourceImageData    string           `position:"Body" name:"SourceImageData"`
	OssFile            string           `position:"Query" name:"OssFile"`
	SourceImageURL     string           `position:"Body" name:"SourceImageURL"`
	TargetImageData    string           `position:"Body" name:"TargetImageData"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	EditPart           string           `position:"Body" name:"EditPart"`
}

SwapFacialFeaturesRequest is the request struct for api SwapFacialFeatures

func CreateSwapFacialFeaturesRequest 

func CreateSwapFacialFeaturesRequest() (request *SwapFacialFeaturesRequest)

CreateSwapFacialFeaturesRequest creates a request to invoke SwapFacialFeatures API

type SwapFacialFeaturesResponse 

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

SwapFacialFeaturesResponse is the response struct for api SwapFacialFeatures

func CreateSwapFacialFeaturesResponse 

func CreateSwapFacialFeaturesResponse() (response *SwapFacialFeaturesResponse)

CreateSwapFacialFeaturesResponse creates a response to parse from SwapFacialFeatures response

type ThresholdsInCompareFace 

type ThresholdsInCompareFace struct {
	Threshold []float64 `json:"Threshold" xml:"Threshold"`
}

ThresholdsInCompareFace is a nested struct in facebody response

type ThresholdsInVerifyFaceMask 

type ThresholdsInVerifyFaceMask struct {
	Thresholds []float64 `json:"Thresholds" xml:"Thresholds"`
}

ThresholdsInVerifyFaceMask is a nested struct in facebody response

type UpdateFaceEntityRequest 

type UpdateFaceEntityRequest struct {
	*requests.RpcRequest
	EntityId           string           `position:"Body" name:"EntityId"`
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	OssFile            string           `position:"Query" name:"OssFile"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	Labels             string           `position:"Body" name:"Labels"`
	DbName             string           `position:"Body" name:"DbName"`
}

UpdateFaceEntityRequest is the request struct for api UpdateFaceEntity

func CreateUpdateFaceEntityRequest 

func CreateUpdateFaceEntityRequest() (request *UpdateFaceEntityRequest)

CreateUpdateFaceEntityRequest creates a request to invoke UpdateFaceEntity API

type UpdateFaceEntityResponse 

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

UpdateFaceEntityResponse is the response struct for api UpdateFaceEntity

func CreateUpdateFaceEntityResponse 

func CreateUpdateFaceEntityResponse() (response *UpdateFaceEntityResponse)

CreateUpdateFaceEntityResponse creates a response to parse from UpdateFaceEntity response

type UpperColor 

type UpperColor struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

UpperColor is a nested struct in facebody response

type UpperWear 

type UpperWear struct {
	Score float64 `json:"Score" xml:"Score"`
	Name  string  `json:"Name" xml:"Name"`
}

UpperWear is a nested struct in facebody response

type VerifyFaceMaskRequest 

type VerifyFaceMaskRequest struct {
	*requests.RpcRequest
	FormatResultToJson requests.Boolean `position:"Query" name:"FormatResultToJson"`
	RefData            string           `position:"Body" name:"RefData"`
	OssFile            string           `position:"Query" name:"OssFile"`
	ImageData          string           `position:"Body" name:"ImageData"`
	RequestProxyBy     string           `position:"Query" name:"RequestProxyBy"`
	ImageURL           string           `position:"Body" name:"ImageURL"`
	RefUrl             string           `position:"Body" name:"RefUrl"`
}

VerifyFaceMaskRequest is the request struct for api VerifyFaceMask

func CreateVerifyFaceMaskRequest 

func CreateVerifyFaceMaskRequest() (request *VerifyFaceMaskRequest)

CreateVerifyFaceMaskRequest creates a request to invoke VerifyFaceMask API

type VerifyFaceMaskResponse 

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

VerifyFaceMaskResponse is the response struct for api VerifyFaceMask

func CreateVerifyFaceMaskResponse 

func CreateVerifyFaceMaskResponse() (response *VerifyFaceMaskResponse)

CreateVerifyFaceMaskResponse creates a response to parse from VerifyFaceMask 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.