add pb.go

554325746@qq.com

2019-06-19 ff18b2b551170a5d8d36d6261115f65494947324

add pb.go

 sdk.pb.go

@@ -514,20 +514,73 @@
}

// sdk face property
type ParamFacePos struct {
type ResultFaceDetect struct {
    Pos                  *FacePos    `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
    Result               *ThftResult `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
    Img                  *Image      `protobuf:"bytes,3,opt,name=img,proto3" json:"img,omitempty"`
    XXX_NoUnkeyedLiteral struct{}    `json:"-"`
    XXX_unrecognized     []byte      `json:"-"`
    XXX_sizecache        int32       `json:"-"`
}

func (m *ResultFaceDetect) Reset()         { *m = ResultFaceDetect{} }
func (m *ResultFaceDetect) String() string { return proto.CompactTextString(m) }
func (*ResultFaceDetect) ProtoMessage()    {}
func (*ResultFaceDetect) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{6}
}
func (m *ResultFaceDetect) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ResultFaceDetect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ResultFaceDetect.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *ResultFaceDetect) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ResultFaceDetect.Merge(m, src)
}
func (m *ResultFaceDetect) XXX_Size() int {
    return m.Size()
}
func (m *ResultFaceDetect) XXX_DiscardUnknown() {
    xxx_messageInfo_ResultFaceDetect.DiscardUnknown(m)
}

var xxx_messageInfo_ResultFaceDetect proto.InternalMessageInfo

func (m *ResultFaceDetect) GetPos() *FacePos {
    if m != nil {
        return m.Pos
    }
    return nil
}

func (m *ResultFaceDetect) GetResult() *ThftResult {
    if m != nil {
        return m.Result
    }
    return nil
}

type ParamFacePos struct {
    Faces                []*ResultFaceDetect `protobuf:"bytes,1,rep,name=faces,proto3" json:"faces,omitempty"`
    XXX_NoUnkeyedLiteral struct{}            `json:"-"`
    XXX_unrecognized     []byte              `json:"-"`
    XXX_sizecache        int32               `json:"-"`
}

func (m *ParamFacePos) Reset()         { *m = ParamFacePos{} }
func (m *ParamFacePos) String() string { return proto.CompactTextString(m) }
func (*ParamFacePos) ProtoMessage()    {}
func (*ParamFacePos) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{6}
    return fileDescriptor_70decb0fb6f436df, []int{7}
}
func (m *ParamFacePos) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -556,23 +609,56 @@

var xxx_messageInfo_ParamFacePos proto.InternalMessageInfo

func (m *ParamFacePos) GetPos() *FacePos {
func (m *ParamFacePos) GetFaces() []*ResultFaceDetect {
    if m != nil {
        return m.Pos
        return m.Faces
    }
    return nil
}

func (m *ParamFacePos) GetResult() *ThftResult {
    if m != nil {
        return m.Result
    }
    return nil
type ParamFaceFeature struct {
    Feats                [][]byte `protobuf:"bytes,1,rep,name=feats,proto3" json:"feats,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *ParamFacePos) GetImg() *Image {
func (m *ParamFaceFeature) Reset()         { *m = ParamFaceFeature{} }
func (m *ParamFaceFeature) String() string { return proto.CompactTextString(m) }
func (*ParamFaceFeature) ProtoMessage()    {}
func (*ParamFaceFeature) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{8}
}
func (m *ParamFaceFeature) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ParamFaceFeature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ParamFaceFeature.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *ParamFaceFeature) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ParamFaceFeature.Merge(m, src)
}
func (m *ParamFaceFeature) XXX_Size() int {
    return m.Size()
}
func (m *ParamFaceFeature) XXX_DiscardUnknown() {
    xxx_messageInfo_ParamFaceFeature.DiscardUnknown(m)
}

var xxx_messageInfo_ParamFaceFeature proto.InternalMessageInfo

func (m *ParamFaceFeature) GetFeats() [][]byte {
    if m != nil {
        return m.Img
        return m.Feats
    }
    return nil
}
@@ -590,7 +676,7 @@
func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
func (*ParamFaceCompare) ProtoMessage()    {}
func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{7}
    return fileDescriptor_70decb0fb6f436df, []int{9}
}
func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -636,7 +722,6 @@
// sdk yolo detect
type ParamYoloObj struct {
    Infos                []*ObjInfo `protobuf:"bytes,1,rep,name=infos,proto3" json:"infos,omitempty"`
    Img                  *Image     `protobuf:"bytes,2,opt,name=img,proto3" json:"img,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
@@ -646,7 +731,7 @@
func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
func (*ParamYoloObj) ProtoMessage()    {}
func (*ParamYoloObj) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{8}
    return fileDescriptor_70decb0fb6f436df, []int{10}
}
func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -682,13 +767,6 @@
    return nil
}

func (m *ParamYoloObj) GetImg() *Image {
    if m != nil {
        return m.Img
    }
    return nil
}

func init() {
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -696,7 +774,9 @@
    proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
    proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
    proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
    proto.RegisterType((*ResultFaceDetect)(nil), "protomsg.ResultFaceDetect")
    proto.RegisterType((*ParamFacePos)(nil), "protomsg.ParamFacePos")
    proto.RegisterType((*ParamFaceFeature)(nil), "protomsg.ParamFaceFeature")
    proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
    proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
}
@@ -704,44 +784,46 @@
func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

var fileDescriptor_70decb0fb6f436df = []byte{
    // 590 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
    0x10, 0xc6, 0x76, 0xed, 0x34, 0xd3, 0x0a, 0xca, 0x52, 0x21, 0x8b, 0x43, 0x14, 0x0c, 0xa2, 0x41,
    0x40, 0x10, 0xe1, 0x8e, 0x04, 0x14, 0xa4, 0x48, 0x40, 0xa3, 0x15, 0x1c, 0xe0, 0xb6, 0x76, 0xd6,
    0x3f, 0xc5, 0xf6, 0x2e, 0xf6, 0x46, 0xc5, 0x77, 0x1e, 0x82, 0x47, 0xe2, 0xc0, 0x81, 0x47, 0x40,
    0x41, 0xbc, 0x07, 0xda, 0xf1, 0x3a, 0x49, 0x45, 0x7a, 0xe2, 0xca, 0x29, 0xf3, 0xcd, 0x7c, 0x99,
    0x9f, 0x6f, 0x76, 0x0c, 0xfd, 0x7a, 0xfe, 0x71, 0x2c, 0x2b, 0xa1, 0x04, 0xd9, 0xc5, 0x9f, 0xa2,
    0x4e, 0x6e, 0x40, 0xc8, 0x6a, 0xde, 0x7a, 0x83, 0x29, 0xb8, 0xd3, 0x82, 0x25, 0x9c, 0x1c, 0x82,
    0x7b, 0x96, 0xcd, 0x55, 0xea, 0x5b, 0x43, 0x6b, 0xe4, 0xd2, 0x16, 0x90, 0xeb, 0xe0, 0xa5, 0x3c,
    0x4b, 0x52, 0xe5, 0xdb, 0xe8, 0x36, 0x88, 0x10, 0xd8, 0x99, 0x33, 0xc5, 0x7c, 0x67, 0x68, 0x8d,
    0xf6, 0x29, 0xda, 0x41, 0x02, 0xfd, 0x97, 0x2c, 0xe2, 0x4f, 0xcb, 0x24, 0xe7, 0xe4, 0x00, 0x9c,
    0x86, 0x9d, 0x99, 0x64, 0xda, 0xd4, 0x05, 0x64, 0xa6, 0xa2, 0xd4, 0x64, 0x6a, 0x81, 0x4e, 0x54,
    0x89, 0x3c, 0xc7, 0x44, 0x2e, 0x45, 0x9b, 0x0c, 0x00, 0x22, 0x51, 0xc6, 0xd9, 0x9c, 0x97, 0x11,
    0xf7, 0x77, 0x86, 0xd6, 0xc8, 0xa6, 0x1b, 0x9e, 0xe0, 0x33, 0xc0, 0xdb, 0x34, 0x56, 0x94, 0xd7,
    0x8b, 0x5c, 0xe9, 0x16, 0x13, 0x5e, 0xce, 0x79, 0x65, 0x8a, 0x19, 0xa4, 0x3b, 0x60, 0x09, 0x37,
    0xd5, 0xb4, 0x89, 0xb5, 0x58, 0xc4, 0x57, 0xb5, 0x58, 0xc4, 0xf5, 0xbf, 0x43, 0xce, 0x16, 0xaa,
    0xc1, 0x3a, 0x2e, 0x35, 0x48, 0x77, 0x5b, 0x17, 0x59, 0xce, 0x7d, 0xb7, 0xed, 0x16, 0x41, 0xf0,
    0xdd, 0x86, 0x9e, 0x9e, 0x71, 0x26, 0x6a, 0x72, 0x07, 0xbc, 0x2a, 0xd2, 0x00, 0xeb, 0xee, 0x4d,
    0x2e, 0x8f, 0x3b, 0x81, 0xc7, 0x94, 0x47, 0x8a, 0x9a, 0x28, 0x79, 0x00, 0x7d, 0xa9, 0x5e, 0xf1,
    0x58, 0xbd, 0x68, 0xda, 0x6e, 0xf6, 0x26, 0x57, 0xd6, 0xd4, 0x99, 0xc8, 0x4a, 0x45, 0xd7, 0x0c,
    0xf2, 0x10, 0x40, 0x2a, 0xaa, 0x45, 0xd6, 0x7c, 0x67, 0x3b, 0x7f, 0x83, 0x42, 0xee, 0x42, 0x4f,
    0xaa, 0xd7, 0x62, 0xa1, 0x52, 0x1c, 0x61, 0x0b, 0xbb, 0x8b, 0x93, 0x23, 0xf0, 0xa4, 0x7a, 0x23,
    0xea, 0x76, 0xaa, 0x2d, 0x4c, 0x13, 0x26, 0xf7, 0xc0, 0x8b, 0x71, 0x8f, 0xbe, 0x87, 0xc4, 0x6b,
    0x6b, 0xe2, 0x6a, 0xc5, 0xd4, 0x50, 0x88, 0x0f, 0xbd, 0x4f, 0x0b, 0x96, 0x67, 0xaa, 0xf1, 0x7b,
    0x28, 0x56, 0x07, 0xf5, 0x22, 0x63, 0x16, 0x65, 0x2c, 0x3f, 0xd6, 0x6f, 0x65, 0x17, 0xdf, 0xca,
    0x86, 0x27, 0xf8, 0x6d, 0xc3, 0xae, 0xce, 0x37, 0x2d, 0x63, 0xf1, 0x5f, 0xcf, 0x7f, 0xd6, 0x53,
    0x3f, 0xe6, 0x58, 0xcb, 0x79, 0xec, 0xf7, 0x87, 0xd6, 0xc8, 0xa1, 0x06, 0x05, 0xef, 0xa0, 0x77,
    0x12, 0x9e, 0xa2, 0xca, 0xb7, 0xc1, 0xad, 0xa2, 0x93, 0xf0, 0xf4, 0x02, 0x91, 0xdb, 0xa0, 0xbe,
    0x1d, 0xd5, 0xc8, 0xee, 0x76, 0x54, 0x23, 0xf5, 0xed, 0xc8, 0x4a, 0x84, 0x28, 0xa0, 0x4d, 0xd1,
    0x0e, 0xbe, 0x58, 0xb0, 0x3f, 0x63, 0x15, 0x2b, 0xba, 0x93, 0xb8, 0x05, 0x8e, 0x14, 0xb5, 0x49,
    0x7d, 0xf5, 0xfc, 0x8c, 0x33, 0x51, 0x53, 0x1d, 0x25, 0xf7, 0xc1, 0xab, 0xf0, 0x72, 0xcd, 0xf2,
    0x0e, 0xd7, 0xbc, 0xf5, 0x55, 0x53, 0xc3, 0x21, 0x37, 0xc1, 0xc9, 0x8a, 0xe4, 0xef, 0xbd, 0xe1,
    0x47, 0x8b, 0xea, 0x58, 0xf0, 0x04, 0x0e, 0x56, 0x5d, 0x3c, 0x17, 0x85, 0x64, 0x15, 0x7e, 0xcd,
    0x62, 0xce, 0xd4, 0x23, 0xec, 0x65, 0x9f, 0xb6, 0xa0, 0xf3, 0x4e, 0xb0, 0xb2, 0xf1, 0x4e, 0x82,
    0x0f, 0x66, 0x8a, 0xf7, 0x22, 0x17, 0x7a, 0xf8, 0x23, 0x70, 0xb3, 0x32, 0xc6, 0x39, 0x9c, 0xf3,
    0x73, 0x18, 0x11, 0x69, 0x1b, 0xef, 0x7a, 0xb3, 0x2f, 0xee, 0xed, 0xd9, 0xc1, 0xb7, 0xe5, 0xc0,
    0xfa, 0xb1, 0x1c, 0x58, 0x3f, 0x97, 0x03, 0xeb, 0xeb, 0xaf, 0xc1, 0xa5, 0xd0, 0x43, 0xda, 0xe3,
    0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4b, 0x3e, 0x0d, 0xdf, 0x9a, 0x05, 0x00, 0x00,
    // 615 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0x4d, 0x6f, 0xd3, 0x4c,
    0x10, 0x7e, 0x1d, 0xd7, 0x4e, 0x33, 0xad, 0x5e, 0xc2, 0x52, 0x21, 0xab, 0x87, 0x28, 0x32, 0x88,
    0x1a, 0x01, 0x85, 0x86, 0x03, 0x37, 0xc4, 0x47, 0xa9, 0x54, 0x09, 0x68, 0xb4, 0x82, 0x03, 0xc7,
    0xb5, 0xb3, 0xfe, 0x28, 0x8e, 0xd7, 0xd8, 0x1b, 0x15, 0xff, 0x13, 0x7e, 0x12, 0x07, 0x0e, 0xfc,
    0x04, 0x54, 0xc4, 0xff, 0x40, 0xb3, 0xbb, 0x8e, 0x5d, 0x29, 0x9c, 0xb8, 0x72, 0xca, 0x3c, 0x33,
    0x8f, 0xe7, 0xe3, 0x99, 0x9d, 0xc0, 0xa8, 0x5e, 0x7c, 0x3c, 0x2c, 0x2b, 0x21, 0x05, 0xd9, 0x56,
    0x3f, 0xcb, 0x3a, 0xd9, 0x87, 0x90, 0xd5, 0x5c, 0x7b, 0xfd, 0x53, 0x70, 0x4e, 0x97, 0x2c, 0xe1,
    0x64, 0x0f, 0x9c, 0x8b, 0x6c, 0x21, 0x53, 0xcf, 0x9a, 0x5a, 0x81, 0x43, 0x35, 0x20, 0x37, 0xc1,
    0x4d, 0x79, 0x96, 0xa4, 0xd2, 0x1b, 0x28, 0xb7, 0x41, 0x84, 0xc0, 0xd6, 0x82, 0x49, 0xe6, 0xd9,
    0x53, 0x2b, 0xd8, 0xa5, 0xca, 0xf6, 0x13, 0x18, 0x9d, 0xb0, 0x88, 0x3f, 0x2f, 0x92, 0x9c, 0x93,
    0x31, 0xd8, 0x0d, 0xbb, 0x30, 0xc9, 0xd0, 0xc4, 0x02, 0x65, 0x26, 0xa3, 0xd4, 0x64, 0xd2, 0x00,
    0x13, 0x55, 0x22, 0xcf, 0x55, 0x22, 0x87, 0x2a, 0x9b, 0x4c, 0x00, 0x22, 0x51, 0xc4, 0xd9, 0x82,
    0x17, 0x11, 0xf7, 0xb6, 0xa6, 0x56, 0x30, 0xa0, 0x3d, 0x8f, 0xff, 0x19, 0xe0, 0x5d, 0x1a, 0x4b,
    0xca, 0xeb, 0x55, 0x2e, 0xb1, 0xc5, 0x84, 0x17, 0x0b, 0x5e, 0x99, 0x62, 0x06, 0x61, 0x07, 0x2c,
    0xe1, 0xa6, 0x1a, 0x9a, 0xaa, 0x16, 0x8b, 0xf8, 0xba, 0x16, 0x8b, 0x38, 0x7e, 0x1d, 0x72, 0xb6,
    0x92, 0x8d, 0xaa, 0xe3, 0x50, 0x83, 0xb0, 0xdb, 0x7a, 0x99, 0xe5, 0xdc, 0x73, 0x74, 0xb7, 0x0a,
    0xf8, 0xdf, 0x06, 0x30, 0xc4, 0x19, 0xe7, 0xa2, 0x26, 0x77, 0xc0, 0xad, 0x22, 0x04, 0xaa, 0xee,
    0xce, 0xec, 0xff, 0xc3, 0x56, 0xe0, 0x43, 0xca, 0x23, 0x49, 0x4d, 0x94, 0x3c, 0x80, 0x51, 0x29,
    0x5f, 0xf3, 0x58, 0xbe, 0x6a, 0x74, 0x37, 0x3b, 0xb3, 0x6b, 0x1d, 0x75, 0x2e, 0xb2, 0x42, 0xd2,
    0x8e, 0x41, 0x1e, 0x02, 0x94, 0x92, 0xa2, 0xc8, 0xc8, 0xb7, 0x37, 0xf3, 0x7b, 0x14, 0x72, 0x17,
    0x86, 0xa5, 0x7c, 0x23, 0x56, 0x32, 0x55, 0x23, 0x6c, 0x60, 0xb7, 0x71, 0x72, 0x00, 0x6e, 0x29,
    0xdf, 0x8a, 0x5a, 0x4f, 0xb5, 0x81, 0x69, 0xc2, 0xe4, 0x1e, 0xb8, 0xb1, 0xda, 0xa3, 0xe7, 0x2a,
    0xe2, 0x8d, 0x8e, 0xb8, 0x5e, 0x31, 0x35, 0x14, 0xe2, 0xc1, 0xf0, 0xd3, 0x8a, 0xe5, 0x99, 0x6c,
    0xbc, 0xa1, 0x12, 0xab, 0x85, 0xb8, 0xc8, 0x98, 0x45, 0x19, 0xcb, 0x8f, 0xf1, 0xad, 0x6c, 0xab,
    0xb7, 0xd2, 0xf3, 0xf8, 0xbf, 0x06, 0xb0, 0x8d, 0xf9, 0x4e, 0x8b, 0x58, 0xfc, 0xd3, 0xf3, 0xaf,
    0xf5, 0xc4, 0xc7, 0x1c, 0xa3, 0x9c, 0xc7, 0xde, 0x68, 0x6a, 0x05, 0x36, 0x35, 0xc8, 0x7f, 0x0f,
    0xc3, 0xb3, 0xf0, 0x5c, 0xa9, 0x7c, 0x1b, 0x9c, 0x2a, 0x3a, 0x0b, 0xcf, 0xff, 0x20, 0xb2, 0x0e,
    0xe2, 0xed, 0xc8, 0xa6, 0x6c, 0x6f, 0x47, 0x36, 0x25, 0xde, 0x4e, 0x59, 0x89, 0x50, 0x09, 0x38,
    0xa0, 0xca, 0xf6, 0x39, 0x8c, 0xf5, 0x0d, 0xe2, 0x0c, 0xc7, 0x5c, 0xf2, 0x48, 0x92, 0x5b, 0x60,
    0x97, 0xa2, 0x36, 0xd9, 0xaf, 0x5f, 0x1d, 0x73, 0x2e, 0x6a, 0x8a, 0x51, 0x72, 0x1f, 0xdc, 0x4a,
    0x7d, 0x68, 0xf6, 0xb7, 0xd7, 0xf1, 0xba, 0xc3, 0xa6, 0x86, 0xe3, 0x3f, 0x83, 0xdd, 0x39, 0xab,
    0xd8, 0xb2, 0x3d, 0xbc, 0x47, 0xe0, 0xe0, 0x5c, 0x58, 0xc4, 0x0e, 0x76, 0x66, 0xfb, 0xfd, 0x11,
    0xae, 0x76, 0x43, 0x35, 0xd1, 0x0f, 0x60, 0xbc, 0xce, 0x70, 0xc2, 0x99, 0x5c, 0x55, 0xea, 0xff,
    0x2e, 0xe6, 0x4c, 0xea, 0x2c, 0xbb, 0x54, 0x03, 0xff, 0x69, 0x8f, 0xf9, 0x52, 0x2c, 0x4b, 0xd6,
    0x31, 0x8f, 0xd4, 0x50, 0x86, 0x79, 0xd4, 0x7a, 0x67, 0x6a, 0x04, 0xe3, 0x9d, 0xf9, 0x4f, 0x4c,
    0xaf, 0x1f, 0x44, 0x2e, 0x50, 0xc8, 0x03, 0x70, 0xb2, 0x22, 0x16, 0x6d, 0xaf, 0x3d, 0x41, 0xcc,
    0x42, 0xa8, 0x8e, 0xbf, 0x18, 0x7f, 0xbd, 0x9c, 0x58, 0xdf, 0x2f, 0x27, 0xd6, 0x8f, 0xcb, 0x89,
    0xf5, 0xe5, 0xe7, 0xe4, 0xbf, 0xd0, 0x55, 0xd4, 0xc7, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x64,
    0xac, 0xaa, 0x80, 0xc3, 0x05, 0x00, 0x00,
}

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -1100,7 +1182,7 @@
    return i, nil
}

func (m *ParamFacePos) Marshal() (dAtA []byte, err error) {
func (m *ResultFaceDetect) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
@@ -1110,7 +1192,7 @@
    return dAtA[:n], nil
}

func (m *ParamFacePos) MarshalTo(dAtA []byte) (int, error) {
func (m *ResultFaceDetect) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
@@ -1135,15 +1217,67 @@
        }
        i += n15
    }
    if m.Img != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.Img.Size()))
        n16, err16 := m.Img.MarshalTo(dAtA[i:])
        if err16 != nil {
            return 0, err16
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *ParamFacePos) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *ParamFacePos) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Faces) > 0 {
        for _, msg := range m.Faces {
            dAtA[i] = 0xa
            i++
            i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
        i += n16
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *ParamFaceFeature) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *ParamFaceFeature) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Feats) > 0 {
        for _, b := range m.Feats {
            dAtA[i] = 0xa
            i++
            i = encodeVarintSdk(dAtA, i, uint64(len(b)))
            i += copy(dAtA[i:], b)
        }
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
@@ -1210,16 +1344,6 @@
            }
            i += n
        }
    }
    if m.Img != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.Img.Size()))
        n17, err17 := m.Img.MarshalTo(dAtA[i:])
        if err17 != nil {
            return 0, err17
        }
        i += n17
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
@@ -1420,7 +1544,7 @@
    return n
}

func (m *ParamFacePos) Size() (n int) {
func (m *ResultFaceDetect) Size() (n int) {
    if m == nil {
        return 0
    }
@@ -1434,9 +1558,41 @@
        l = m.Result.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovSdk(uint64(l))
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *ParamFacePos) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if len(m.Faces) > 0 {
        for _, e := range m.Faces {
            l = e.Size()
            n += 1 + l + sovSdk(uint64(l))
        }
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *ParamFaceFeature) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if len(m.Feats) > 0 {
        for _, b := range m.Feats {
            l = len(b)
            n += 1 + l + sovSdk(uint64(l))
        }
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
@@ -1475,10 +1631,6 @@
            l = e.Size()
            n += 1 + l + sovSdk(uint64(l))
        }
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
@@ -2681,7 +2833,7 @@
    }
    return nil
}
func (m *ParamFacePos) Unmarshal(dAtA []byte) error {
func (m *ResultFaceDetect) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
@@ -2704,10 +2856,10 @@
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: ParamFacePos: wiretype end group for non-group")
            return fmt.Errorf("proto: ResultFaceDetect: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
            return fmt.Errorf("proto: ResultFaceDetect: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
@@ -2782,9 +2934,63 @@
                return err
            }
            iNdEx = postIndex
        case 3:
        default:
            iNdEx = preIndex
            skippy, err := skipSdk(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthSdk
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthSdk
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ParamFacePos) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowSdk
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: ParamFacePos: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ParamFacePos: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Img", wireType)
                return fmt.Errorf("proto: wrong wireType = %d for field Faces", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
@@ -2811,12 +3017,96 @@
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Img == nil {
                m.Img = &Image{}
            }
            if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            m.Faces = append(m.Faces, &ResultFaceDetect{})
            if err := m.Faces[len(m.Faces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipSdk(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthSdk
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthSdk
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ParamFaceFeature) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowSdk
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: ParamFaceFeature: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ParamFaceFeature: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Feats", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Feats = append(m.Feats, make([]byte, postIndex-iNdEx))
            copy(m.Feats[len(m.Feats)-1], dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        default:
            iNdEx = preIndex
@@ -3025,42 +3315,6 @@
            }
            m.Infos = append(m.Infos, &ObjInfo{})
            if err := m.Infos[len(m.Infos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Img", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Img == nil {
                m.Img = &Image{}
            }
            if err := m.Img.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex

 sdk.proto

@@ -51,10 +51,15 @@
}

// sdk face property
message ParamFacePos{
message ResultFaceDetect{
    FacePos pos = 1;
    ThftResult result = 2;
    Image img = 3;
}
message ParamFacePos{
    repeated ResultFaceDetect faces = 1;
}
message ParamFaceFeature{
    repeated bytes feats = 1;
}
// sdk face extract
message ParamFaceCompare{
@@ -65,5 +70,4 @@
// sdk yolo detect
message ParamYoloObj{
    repeated ObjInfo infos = 1;
    Image img = 2;
}