add sdk struct

zhangmeng

2019-05-20 00f89f21a0e26cb7b540d19b90bd0ed1d2ddcc29

add sdk struct

 protomsg.pb.go

@@ -736,6 +736,112 @@
    return 0
}

// sdk face property
type ParamFaceProperty struct {
    Pos *FacePos `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
    Img *Image   `protobuf:"bytes,2,opt,name=img,proto3" json:"img,omitempty"`
}

func (m *ParamFaceProperty) Reset()         { *m = ParamFaceProperty{} }
func (m *ParamFaceProperty) String() string { return proto.CompactTextString(m) }
func (*ParamFaceProperty) ProtoMessage()    {}
func (*ParamFaceProperty) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{10}
}
func (m *ParamFaceProperty) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ParamFaceProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ParamFaceProperty.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 *ParamFaceProperty) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ParamFaceProperty.Merge(m, src)
}
func (m *ParamFaceProperty) XXX_Size() int {
    return m.Size()
}
func (m *ParamFaceProperty) XXX_DiscardUnknown() {
    xxx_messageInfo_ParamFaceProperty.DiscardUnknown(m)
}

var xxx_messageInfo_ParamFaceProperty proto.InternalMessageInfo

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

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

// sdk face extract
type ParamFaceCompare struct {
    Feat1 []byte `protobuf:"bytes,1,opt,name=feat1,proto3" json:"feat1,omitempty"`
    Feat2 []byte `protobuf:"bytes,2,opt,name=feat2,proto3" json:"feat2,omitempty"`
}

func (m *ParamFaceCompare) Reset()         { *m = ParamFaceCompare{} }
func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
func (*ParamFaceCompare) ProtoMessage()    {}
func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{11}
}
func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ParamFaceCompare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ParamFaceCompare.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 *ParamFaceCompare) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ParamFaceCompare.Merge(m, src)
}
func (m *ParamFaceCompare) XXX_Size() int {
    return m.Size()
}
func (m *ParamFaceCompare) XXX_DiscardUnknown() {
    xxx_messageInfo_ParamFaceCompare.DiscardUnknown(m)
}

var xxx_messageInfo_ParamFaceCompare proto.InternalMessageInfo

func (m *ParamFaceCompare) GetFeat1() []byte {
    if m != nil {
        return m.Feat1
    }
    return nil
}

func (m *ParamFaceCompare) GetFeat2() []byte {
    if m != nil {
        return m.Feat2
    }
    return nil
}

func init() {
    proto.RegisterType((*TaskLabel)(nil), "protomsg.TaskLabel")
    proto.RegisterType((*SdkMessage)(nil), "protomsg.SdkMessage")
@@ -747,50 +853,57 @@
    proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
    proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
    proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
    proto.RegisterType((*ParamFaceProperty)(nil), "protomsg.ParamFaceProperty")
    proto.RegisterType((*ParamFaceCompare)(nil), "protomsg.ParamFaceCompare")
}

func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
@@ -1281,6 +1394,74 @@
    return i, nil
}

func (m *ParamFaceProperty) 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 *ParamFaceProperty) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Pos != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Pos.Size()))
        n15, err15 := m.Pos.MarshalTo(dAtA[i:])
        if err15 != nil {
            return 0, err15
        }
        i += n15
    }
    if m.Img != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Img.Size()))
        n16, err16 := m.Img.MarshalTo(dAtA[i:])
        if err16 != nil {
            return 0, err16
        }
        i += n16
    }
    return i, nil
}

func (m *ParamFaceCompare) 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 *ParamFaceCompare) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Feat1) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat1)))
        i += copy(dAtA[i:], m.Feat1)
    }
    if len(m.Feat2) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Feat2)))
        i += copy(dAtA[i:], m.Feat2)
    }
    return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -1531,6 +1712,40 @@
    }
    if m.Prob != 0 {
        n += 5
    }
    return n
}

func (m *ParamFaceProperty) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Pos != nil {
        l = m.Pos.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *ParamFaceCompare) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Feat1)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.Feat2)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}
@@ -3235,6 +3450,252 @@
    }
    return nil
}
func (m *ParamFaceProperty) 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 ErrIntOverflowProtomsg
            }
            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: ParamFaceProperty: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ParamFaceProperty: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Pos == nil {
                m.Pos = &FacePos{}
            }
            if err := m.Pos.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 ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            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
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ParamFaceCompare) 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 ErrIntOverflowProtomsg
            }
            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: ParamFaceCompare: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ParamFaceCompare: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Feat1", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Feat1 = append(m.Feat1[:0], dAtA[iNdEx:postIndex]...)
            if m.Feat1 == nil {
                m.Feat1 = []byte{}
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Feat2", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Feat2 = append(m.Feat2[:0], dAtA[iNdEx:postIndex]...)
            if m.Feat2 == nil {
                m.Feat2 = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipProtomsg(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0

 protomsg.proto

@@ -70,3 +70,13 @@
    int32 typ = 2;
    float prob = 3;
}
// sdk face property
message ParamFaceProperty{
    FacePos pos = 1;
    Image img = 2;
}
// sdk face extract
message ParamFaceCompare{
    bytes feat1 = 1;
    bytes feat2 = 2;
}