add face features

zhangmeng

2019-06-19 54291ef598c1a8f179b62da080540923b87125be

add face features

 sdk.pb.go

@@ -592,6 +592,50 @@
    return nil
}

type ParamFaceFeature struct {
    Feats [][]byte `protobuf:"bytes,1,rep,name=feats,proto3" json:"feats,omitempty"`
}

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.Feats
    }
    return nil
}

// sdk face extract
type ParamFaceCompare struct {
    Feat1 []byte `protobuf:"bytes,1,opt,name=feat1,proto3" json:"feat1,omitempty"`
@@ -602,7 +646,7 @@
func (m *ParamFaceCompare) String() string { return proto.CompactTextString(m) }
func (*ParamFaceCompare) ProtoMessage()    {}
func (*ParamFaceCompare) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{8}
    return fileDescriptor_70decb0fb6f436df, []int{9}
}
func (m *ParamFaceCompare) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -654,7 +698,7 @@
func (m *ParamYoloObj) String() string { return proto.CompactTextString(m) }
func (*ParamYoloObj) ProtoMessage()    {}
func (*ParamYoloObj) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{9}
    return fileDescriptor_70decb0fb6f436df, []int{10}
}
func (m *ParamYoloObj) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -699,6 +743,7 @@
    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")
}
@@ -706,46 +751,46 @@
func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -1154,6 +1199,32 @@
    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)
        }
    }
    return i, nil
}

func (m *ParamFaceCompare) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
@@ -1415,6 +1486,21 @@
    if len(m.Faces) > 0 {
        for _, e := range m.Faces {
            l = e.Size()
            n += 1 + l + sovSdk(uint64(l))
        }
    }
    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))
        }
    }
@@ -2854,6 +2940,91 @@
    }
    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
            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
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ParamFaceCompare) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0

 sdk.proto

@@ -58,6 +58,9 @@
message ParamFacePos{
    repeated ResultFaceDetect faces = 1;
}
message ParamFaceFeature{
    repeated bytes feats = 1;
}
// sdk face extract
message ParamFaceCompare{
    bytes feat1 = 1;