new pb.go

liuxiaolong

2019-06-19 22f649a39f7a453f516469feaba5723c6c9181c2

new pb.go

 protomsg.pb.go

File was deleted

 protomsg.proto

@@ -3,109 +3,27 @@

package protomsg;

message SdkmsgWithTask {
    string sdkid = 1;
    string sdktype = 2;
    string sdkName = 3;
    bytes  sdkdata = 4;
}

message TaskLabel {
    string taskid = 1;
    repeated string sdkids = 2;
    int32 index = 3 ;
    string taskname = 2;
    repeated SdkmsgWithTask sdkinfos = 3;
    int32 index = 4 ;
}

//SdkMessage struct test
message SdkMessage {
    string cid = 1;
    TaskLabel tasklab = 2;
    bytes    data =3 ;

    Personaction personaction =4;
    Vediopersons vedioperson = 5;
    string    caddr = 2;
    TaskLabel tasklab =3 ;
    bytes      data = 4;
}

message Personaction{
    string imgKey       = 1; 
    string videoReqNum  = 2;
    string sdkType      = 3;
    string picName      = 4;
    string content      = 5;
    string cluster_id   = 6;
    string personPicUrl = 7;
    string channlId     = 8;
    string likeDate     = 9;

    string picAddress   = 10;
    string picMaxUrl    = 11;
    string picDate      = 12;
    string picLocalUrl  = 13;
    string isDelete     = 14;
    string likePer      = 15;
    string baseName     = 16;
    string videoNum     = 17;
    string collection   = 18;
    string picSmUrl     = 19;
    
    string indeviceid   = 20;
    string idcard       = 21;
    string ack_alarm    = 22;
    string personId     = 23;
    string id           = 24;
    string indevicename = 25;
    string faceFeature  = 26;
    string personIsHub  = 27;
    string videoIp      = 28;
    string taskId       = 29;
}

message PersonBaseInfo {
    string personNamae  = 1;
    string iDCard       = 2;
    string gender       = 3;
    string personPicUrl = 4;
    string likePer      = 5;
    string tableId      = 6;
    string monitorLevel = 7;
    string personId     = 8;
    string phoneNum     = 9;
    string content      = 10;
    string tableName    = 11;
}

message Vediopersons {
    string iD           = 1;
    string videoReqNum  = 2;
    string sdkType=3;
    string gender=4;
    string picName=5;
    string content=6;
    string personPicUrl=7;
    string channlId=8;
    string likeDate=9;
    string race=10;
    string pciAddress=11;
    string picMaxUrl=12;
    string age=13;
    string picDate=14;
    string picLocalUrl=15;
    string isDelete=16;
    repeated string tableName=17;
    string videoNum=18;
    string picSmUrl=19;
    string simleLevel=20;
    string indeviceId=21;
    repeated string iDcard=22;
    repeated string personId=23;
    string beautyLevel=24;
    string indeviceName=25;
    string faceFeature=26;
    string personIsHub=27;
    string videoIp=28;
    string ackAlarm=29;
    string clusterId=30;
    string taskId=31;
    string taskName=32;
    repeated PersonBaseInfo baseinfo =33;
    string collection=34;
    string ageDescription=35;
    repeated string tableId=36;
}


//Area结构体
message Area{
@@ -288,4 +206,3 @@
    string type = 7;
    int32 defence_state = 8;
}


 sdk.pb.go

@@ -496,17 +496,67 @@
}

// 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"`
}

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

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)
@@ -535,23 +585,53 @@

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

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
}
@@ -566,7 +646,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)
@@ -612,14 +692,13 @@
// 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"`
}

func (m *ParamYoloObj) Reset()         { *m = ParamYoloObj{} }
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)
@@ -655,13 +734,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")
@@ -669,7 +741,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")
}
@@ -677,45 +751,46 @@
func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

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
        }
    }
    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
}
@@ -1160,16 +1281,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
    }
    return i, nil
}
@@ -1349,7 +1460,7 @@
    return n
}

func (m *ParamFacePos) Size() (n int) {
func (m *ResultFaceDetect) Size() (n int) {
    if m == nil {
        return 0
    }
@@ -1363,9 +1474,35 @@
        l = m.Result.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.Img != nil {
        l = m.Img.Size()
    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))
        }
    }
    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))
        }
    }
    return n
}
@@ -1398,10 +1535,6 @@
            l = e.Size()
            n += 1 + l + sovSdk(uint64(l))
        }
    }
    if m.Img != nil {
        l = m.Img.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    return n
}
@@ -2595,7 +2728,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 {
@@ -2618,10 +2751,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:
@@ -2696,9 +2829,62 @@
                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
            }
            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 {
@@ -2725,12 +2911,95 @@
            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
            }
            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
@@ -2937,42 +3206,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;
}