add vehicle plate id

zhangmeng

2019-11-21 0de9a1fa3da3f4bbbe90f9cfd797fe1f8999da0a

add vehicle plate id

 sdk.pb.go

@@ -1267,6 +1267,238 @@
    return nil
}

type PlateVehicleID struct {
    NPlateFlag       int32   `protobuf:"varint,1,opt,name=nPlateFlag,proto3" json:"nPlateFlag,omitempty"`
    NColor           int32   `protobuf:"varint,2,opt,name=nColor,proto3" json:"nColor,omitempty"`
    NType            int32   `protobuf:"varint,3,opt,name=nType,proto3" json:"nType,omitempty"`
    License          string  `protobuf:"bytes,4,opt,name=license,proto3" json:"license,omitempty"`
    NConfidence      int32   `protobuf:"varint,5,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
    NCharNum         int32   `protobuf:"varint,6,opt,name=nCharNum,proto3" json:"nCharNum,omitempty"`
    NCharConfidence  []byte  `protobuf:"bytes,7,opt,name=nCharConfidence,proto3" json:"nCharConfidence,omitempty"`
    RcLocation       *Rect   `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
    RcCarLocation    *Rect   `protobuf:"bytes,9,opt,name=rcCarLocation,proto3" json:"rcCarLocation,omitempty"`
    VehicleType      string  `protobuf:"bytes,10,opt,name=vehicleType,proto3" json:"vehicleType,omitempty"`
    VehicleBrand     string  `protobuf:"bytes,11,opt,name=vehicleBrand,proto3" json:"vehicleBrand,omitempty"`
    VehicleSub       string  `protobuf:"bytes,12,opt,name=vehicleSub,proto3" json:"vehicleSub,omitempty"`
    VehicleType1     string  `protobuf:"bytes,13,opt,name=vehicleType1,proto3" json:"vehicleType1,omitempty"`
    FvdConf          float32 `protobuf:"fixed32,14,opt,name=fvdConf,proto3" json:"fvdConf,omitempty"`
    FConfdence       float32 `protobuf:"fixed32,15,opt,name=fConfdence,proto3" json:"fConfdence,omitempty"`
    NVehicleSubModel int32   `protobuf:"varint,16,opt,name=nVehicleSubModel,proto3" json:"nVehicleSubModel,omitempty"`
    NVehicleBright   int32   `protobuf:"varint,17,opt,name=nVehicleBright,proto3" json:"nVehicleBright,omitempty"`
    NVehicleColor1   int32   `protobuf:"varint,18,opt,name=nVehicleColor1,proto3" json:"nVehicleColor1,omitempty"`
    NVehicleColor2   int32   `protobuf:"varint,19,opt,name=nVehicleColor2,proto3" json:"nVehicleColor2,omitempty"`
}

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

var xxx_messageInfo_PlateVehicleID proto.InternalMessageInfo

func (m *PlateVehicleID) GetNPlateFlag() int32 {
    if m != nil {
        return m.NPlateFlag
    }
    return 0
}

func (m *PlateVehicleID) GetNColor() int32 {
    if m != nil {
        return m.NColor
    }
    return 0
}

func (m *PlateVehicleID) GetNType() int32 {
    if m != nil {
        return m.NType
    }
    return 0
}

func (m *PlateVehicleID) GetLicense() string {
    if m != nil {
        return m.License
    }
    return ""
}

func (m *PlateVehicleID) GetNConfidence() int32 {
    if m != nil {
        return m.NConfidence
    }
    return 0
}

func (m *PlateVehicleID) GetNCharNum() int32 {
    if m != nil {
        return m.NCharNum
    }
    return 0
}

func (m *PlateVehicleID) GetNCharConfidence() []byte {
    if m != nil {
        return m.NCharConfidence
    }
    return nil
}

func (m *PlateVehicleID) GetRcLocation() *Rect {
    if m != nil {
        return m.RcLocation
    }
    return nil
}

func (m *PlateVehicleID) GetRcCarLocation() *Rect {
    if m != nil {
        return m.RcCarLocation
    }
    return nil
}

func (m *PlateVehicleID) GetVehicleType() string {
    if m != nil {
        return m.VehicleType
    }
    return ""
}

func (m *PlateVehicleID) GetVehicleBrand() string {
    if m != nil {
        return m.VehicleBrand
    }
    return ""
}

func (m *PlateVehicleID) GetVehicleSub() string {
    if m != nil {
        return m.VehicleSub
    }
    return ""
}

func (m *PlateVehicleID) GetVehicleType1() string {
    if m != nil {
        return m.VehicleType1
    }
    return ""
}

func (m *PlateVehicleID) GetFvdConf() float32 {
    if m != nil {
        return m.FvdConf
    }
    return 0
}

func (m *PlateVehicleID) GetFConfdence() float32 {
    if m != nil {
        return m.FConfdence
    }
    return 0
}

func (m *PlateVehicleID) GetNVehicleSubModel() int32 {
    if m != nil {
        return m.NVehicleSubModel
    }
    return 0
}

func (m *PlateVehicleID) GetNVehicleBright() int32 {
    if m != nil {
        return m.NVehicleBright
    }
    return 0
}

func (m *PlateVehicleID) GetNVehicleColor1() int32 {
    if m != nil {
        return m.NVehicleColor1
    }
    return 0
}

func (m *PlateVehicleID) GetNVehicleColor2() int32 {
    if m != nil {
        return m.NVehicleColor2
    }
    return 0
}

type PlateVehicleIDResult struct {
    Result []*PlateVehicleID `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
}

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

var xxx_messageInfo_PlateVehicleIDResult proto.InternalMessageInfo

func (m *PlateVehicleIDResult) GetResult() []*PlateVehicleID {
    if m != nil {
        return m.Result
    }
    return nil
}

func init() {
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -1284,83 +1516,98 @@
    proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
    proto.RegisterType((*PlateCloudID)(nil), "protomsg.PlateCloudID")
    proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
    proto.RegisterType((*PlateVehicleID)(nil), "protomsg.PlateVehicleID")
    proto.RegisterType((*PlateVehicleIDResult)(nil), "protomsg.PlateVehicleIDResult")
}

func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -2225,6 +2472,175 @@
    return i, nil
}

func (m *PlateVehicleID) 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 *PlateVehicleID) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.NPlateFlag != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NPlateFlag))
    }
    if m.NColor != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
    }
    if m.NType != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NType))
    }
    if len(m.License) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
        i += copy(dAtA[i:], m.License)
    }
    if m.NConfidence != 0 {
        dAtA[i] = 0x28
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
    }
    if m.NCharNum != 0 {
        dAtA[i] = 0x30
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
    }
    if len(m.NCharConfidence) > 0 {
        dAtA[i] = 0x3a
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.NCharConfidence)))
        i += copy(dAtA[i:], m.NCharConfidence)
    }
    if m.RcLocation != nil {
        dAtA[i] = 0x42
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
        n20, err20 := m.RcLocation.MarshalTo(dAtA[i:])
        if err20 != nil {
            return 0, err20
        }
        i += n20
    }
    if m.RcCarLocation != nil {
        dAtA[i] = 0x4a
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.RcCarLocation.Size()))
        n21, err21 := m.RcCarLocation.MarshalTo(dAtA[i:])
        if err21 != nil {
            return 0, err21
        }
        i += n21
    }
    if len(m.VehicleType) > 0 {
        dAtA[i] = 0x52
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType)))
        i += copy(dAtA[i:], m.VehicleType)
    }
    if len(m.VehicleBrand) > 0 {
        dAtA[i] = 0x5a
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleBrand)))
        i += copy(dAtA[i:], m.VehicleBrand)
    }
    if len(m.VehicleSub) > 0 {
        dAtA[i] = 0x62
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleSub)))
        i += copy(dAtA[i:], m.VehicleSub)
    }
    if len(m.VehicleType1) > 0 {
        dAtA[i] = 0x6a
        i++
        i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType1)))
        i += copy(dAtA[i:], m.VehicleType1)
    }
    if m.FvdConf != 0 {
        dAtA[i] = 0x75
        i++
        encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FvdConf))))
        i += 4
    }
    if m.FConfdence != 0 {
        dAtA[i] = 0x7d
        i++
        encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FConfdence))))
        i += 4
    }
    if m.NVehicleSubModel != 0 {
        dAtA[i] = 0x80
        i++
        dAtA[i] = 0x1
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleSubModel))
    }
    if m.NVehicleBright != 0 {
        dAtA[i] = 0x88
        i++
        dAtA[i] = 0x1
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleBright))
    }
    if m.NVehicleColor1 != 0 {
        dAtA[i] = 0x90
        i++
        dAtA[i] = 0x1
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor1))
    }
    if m.NVehicleColor2 != 0 {
        dAtA[i] = 0x98
        i++
        dAtA[i] = 0x1
        i++
        i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor2))
    }
    return i, nil
}

func (m *PlateVehicleIDResult) 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 *PlateVehicleIDResult) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Result) > 0 {
        for _, msg := range m.Result {
            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 encodeVarintSdk(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2666,6 +3082,95 @@
}

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

func (m *PlateVehicleID) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.NPlateFlag != 0 {
        n += 1 + sovSdk(uint64(m.NPlateFlag))
    }
    if m.NColor != 0 {
        n += 1 + sovSdk(uint64(m.NColor))
    }
    if m.NType != 0 {
        n += 1 + sovSdk(uint64(m.NType))
    }
    l = len(m.License)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.NConfidence != 0 {
        n += 1 + sovSdk(uint64(m.NConfidence))
    }
    if m.NCharNum != 0 {
        n += 1 + sovSdk(uint64(m.NCharNum))
    }
    l = len(m.NCharConfidence)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.RcLocation != nil {
        l = m.RcLocation.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.RcCarLocation != nil {
        l = m.RcCarLocation.Size()
        n += 1 + l + sovSdk(uint64(l))
    }
    l = len(m.VehicleType)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    l = len(m.VehicleBrand)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    l = len(m.VehicleSub)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    l = len(m.VehicleType1)
    if l > 0 {
        n += 1 + l + sovSdk(uint64(l))
    }
    if m.FvdConf != 0 {
        n += 5
    }
    if m.FConfdence != 0 {
        n += 5
    }
    if m.NVehicleSubModel != 0 {
        n += 2 + sovSdk(uint64(m.NVehicleSubModel))
    }
    if m.NVehicleBright != 0 {
        n += 2 + sovSdk(uint64(m.NVehicleBright))
    }
    if m.NVehicleColor1 != 0 {
        n += 2 + sovSdk(uint64(m.NVehicleColor1))
    }
    if m.NVehicleColor2 != 0 {
        n += 2 + sovSdk(uint64(m.NVehicleColor2))
    }
    return n
}

func (m *PlateVehicleIDResult) Size() (n int) {
    if m == nil {
        return 0
    }
@@ -5769,6 +6274,605 @@
    }
    return nil
}
func (m *PlateVehicleID) 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: PlateVehicleID: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: PlateVehicleID: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NPlateFlag", wireType)
            }
            m.NPlateFlag = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NPlateFlag |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NColor", wireType)
            }
            m.NColor = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NColor |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NType", wireType)
            }
            m.NType = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NType |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field License", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.License = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 5:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NConfidence", wireType)
            }
            m.NConfidence = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NConfidence |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 6:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NCharNum", wireType)
            }
            m.NCharNum = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NCharNum |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 7:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field NCharConfidence", 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.NCharConfidence = append(m.NCharConfidence[:0], dAtA[iNdEx:postIndex]...)
            if m.NCharConfidence == nil {
                m.NCharConfidence = []byte{}
            }
            iNdEx = postIndex
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RcLocation", 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.RcLocation == nil {
                m.RcLocation = &Rect{}
            }
            if err := m.RcLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 9:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RcCarLocation", 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.RcCarLocation == nil {
                m.RcCarLocation = &Rect{}
            }
            if err := m.RcCarLocation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 10:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field VehicleType", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.VehicleType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 11:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field VehicleBrand", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.VehicleBrand = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 12:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field VehicleSub", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.VehicleSub = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 13:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field VehicleType1", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthSdk
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.VehicleType1 = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 14:
            if wireType != 5 {
                return fmt.Errorf("proto: wrong wireType = %d for field FvdConf", wireType)
            }
            var v uint32
            if (iNdEx + 4) > l {
                return io.ErrUnexpectedEOF
            }
            v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
            iNdEx += 4
            m.FvdConf = float32(math.Float32frombits(v))
        case 15:
            if wireType != 5 {
                return fmt.Errorf("proto: wrong wireType = %d for field FConfdence", wireType)
            }
            var v uint32
            if (iNdEx + 4) > l {
                return io.ErrUnexpectedEOF
            }
            v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
            iNdEx += 4
            m.FConfdence = float32(math.Float32frombits(v))
        case 16:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NVehicleSubModel", wireType)
            }
            m.NVehicleSubModel = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NVehicleSubModel |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 17:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NVehicleBright", wireType)
            }
            m.NVehicleBright = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NVehicleBright |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 18:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor1", wireType)
            }
            m.NVehicleColor1 = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NVehicleColor1 |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 19:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field NVehicleColor2", wireType)
            }
            m.NVehicleColor2 = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSdk
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.NVehicleColor2 |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        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 *PlateVehicleIDResult) 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: PlateVehicleIDResult: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: PlateVehicleIDResult: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Result", 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
            }
            m.Result = append(m.Result, &PlateVehicleID{})
            if err := m.Result[len(m.Result)-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 skipSdk(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0

 sdk.proto

@@ -143,3 +143,34 @@
message PlateCloudIDResult {
    repeated PlateCloudID result = 1;
}

message PlateVehicleID{
    int32 nPlateFlag = 1;
    int32 nColor = 2;
    int32 nType = 3;
    string license = 4;
    int32 nConfidence = 5;
    int32 nCharNum = 6;
    bytes nCharConfidence = 7;
    Rect rcLocation = 8;
    Rect rcCarLocation = 9;
    string vehicleType = 10;
    string vehicleBrand = 11;
    string vehicleSub = 12;
    string vehicleType1 = 13;
    float fvdConf = 14;
    float fConfdence = 15;
    int32 nVehicleSubModel = 16;
    int32 nVehicleBright = 17;
    int32 nVehicleColor1 = 18;
    int32 nVehicleColor2 = 19;

    // PCaptureImage [4]uint8 //视频模式识别下抓拍的图片数据
    // NImageWidth   int32    //视频模式下抓拍图像宽度
    // NImageHeight  int32    //视频模式下抓拍图像高度

}

message PlateVehicleIDResult {
    repeated PlateVehicleID result = 1;
}