add pollChannelCount to PollConfig

liuxiaolong

2019-12-04 abd6d2381b39009f8bd9faf47ddf4535a1596fdc

 sdk.pb.go

@@ -1038,15 +1038,346 @@
   return nil
}

// cloud
type PlateIDCloud struct {
   License      string `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
   RcLocation   *Rect  `protobuf:"bytes,2,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NConfidence  int32  `protobuf:"varint,3,opt,name=nConfidence,proto3" json:"nConfidence,omitempty"`
   NType        int32  `protobuf:"varint,4,opt,name=nType,proto3" json:"nType,omitempty"`
   NDirection   int32  `protobuf:"varint,5,opt,name=nDirection,proto3" json:"nDirection,omitempty"`
   NCarColor    int32  `protobuf:"varint,6,opt,name=nCarColor,proto3" json:"nCarColor,omitempty"`
   NCarColor1   int32  `protobuf:"varint,7,opt,name=nCarColor1,proto3" json:"nCarColor1,omitempty"`
   NCarBright   int32  `protobuf:"varint,8,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   FrameNo      int32  `protobuf:"varint,9,opt,name=frameNo,proto3" json:"frameNo,omitempty"`
   FaceWidth    int32  `protobuf:"varint,10,opt,name=faceWidth,proto3" json:"faceWidth,omitempty"`
   FaceHeight   int32  `protobuf:"varint,11,opt,name=faceHeight,proto3" json:"faceHeight,omitempty"`
   GrayFaceFlag int32  `protobuf:"varint,12,opt,name=grayFaceFlag,proto3" json:"grayFaceFlag,omitempty"`
   CharNum      int32  `protobuf:"varint,13,opt,name=charNum,proto3" json:"charNum,omitempty"`
}

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

var xxx_messageInfo_PlateIDCloud proto.InternalMessageInfo

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

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

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

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

func (m *PlateIDCloud) GetNDirection() int32 {
   if m != nil {
      return m.NDirection
   }
   return 0
}

func (m *PlateIDCloud) GetNCarColor() int32 {
   if m != nil {
      return m.NCarColor
   }
   return 0
}

func (m *PlateIDCloud) GetNCarColor1() int32 {
   if m != nil {
      return m.NCarColor1
   }
   return 0
}

func (m *PlateIDCloud) GetNCarBright() int32 {
   if m != nil {
      return m.NCarBright
   }
   return 0
}

func (m *PlateIDCloud) GetFrameNo() int32 {
   if m != nil {
      return m.FrameNo
   }
   return 0
}

func (m *PlateIDCloud) GetFaceWidth() int32 {
   if m != nil {
      return m.FaceWidth
   }
   return 0
}

func (m *PlateIDCloud) GetFaceHeight() int32 {
   if m != nil {
      return m.FaceHeight
   }
   return 0
}

func (m *PlateIDCloud) GetGrayFaceFlag() int32 {
   if m != nil {
      return m.GrayFaceFlag
   }
   return 0
}

func (m *PlateIDCloud) GetCharNum() int32 {
   if m != nil {
      return m.CharNum
   }
   return 0
}

type PlateIDVehicle 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  []int32 `protobuf:"varint,7,rep,packed,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 *PlateIDVehicle) Reset()         { *m = PlateIDVehicle{} }
func (m *PlateIDVehicle) String() string { return proto.CompactTextString(m) }
func (*PlateIDVehicle) ProtoMessage()    {}
func (*PlateIDVehicle) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{14}
}
func (m *PlateIDVehicle) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *PlateIDVehicle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_PlateIDVehicle.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 *PlateIDVehicle) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PlateIDVehicle.Merge(m, src)
}
func (m *PlateIDVehicle) XXX_Size() int {
   return m.Size()
}
func (m *PlateIDVehicle) XXX_DiscardUnknown() {
   xxx_messageInfo_PlateIDVehicle.DiscardUnknown(m)
}

var xxx_messageInfo_PlateIDVehicle proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type PlateIDResult struct {
   Result []*PlateID `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
   // repeated PlateID result = 1;
   // repeated PlateIDCloud result = 1;
   Result []*PlateIDVehicle `protobuf:"bytes,1,rep,name=result,proto3" json:"result,omitempty"`
}

func (m *PlateIDResult) Reset()         { *m = PlateIDResult{} }
func (m *PlateIDResult) String() string { return proto.CompactTextString(m) }
func (*PlateIDResult) ProtoMessage()    {}
func (*PlateIDResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_70decb0fb6f436df, []int{13}
   return fileDescriptor_70decb0fb6f436df, []int{15}
}
func (m *PlateIDResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -1075,7 +1406,7 @@

var xxx_messageInfo_PlateIDResult proto.InternalMessageInfo

func (m *PlateIDResult) GetResult() []*PlateID {
func (m *PlateIDResult) GetResult() []*PlateIDVehicle {
   if m != nil {
      return m.Result
   }
@@ -1096,75 +1427,97 @@
   proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
   proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
   proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
   proto.RegisterType((*PlateIDCloud)(nil), "protomsg.PlateIDCloud")
   proto.RegisterType((*PlateIDVehicle)(nil), "protomsg.PlateIDVehicle")
   proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
}

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

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -1880,6 +2233,246 @@
   return i, nil
}

func (m *PlateIDCloud) 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 *PlateIDCloud) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.License) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
      i += copy(dAtA[i:], m.License)
   }
   if m.RcLocation != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
      n19, err19 := m.RcLocation.MarshalTo(dAtA[i:])
      if err19 != nil {
         return 0, err19
      }
      i += n19
   }
   if m.NConfidence != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
   }
   if m.NType != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
   }
   if m.NDirection != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NDirection))
   }
   if m.NCarColor != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
   }
   if m.NCarColor1 != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor1))
   }
   if m.NCarBright != 0 {
      dAtA[i] = 0x40
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
   }
   if m.FrameNo != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FrameNo))
   }
   if m.FaceWidth != 0 {
      dAtA[i] = 0x50
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceWidth))
   }
   if m.FaceHeight != 0 {
      dAtA[i] = 0x58
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceHeight))
   }
   if m.GrayFaceFlag != 0 {
      dAtA[i] = 0x60
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.GrayFaceFlag))
   }
   if m.CharNum != 0 {
      dAtA[i] = 0x68
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.CharNum))
   }
   return i, nil
}

func (m *PlateIDVehicle) 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 *PlateIDVehicle) 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 {
      dAtA21 := make([]byte, len(m.NCharConfidence)*10)
      var j20 int
      for _, num1 := range m.NCharConfidence {
         num := uint64(num1)
         for num >= 1<<7 {
            dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80)
            num >>= 7
            j20++
         }
         dAtA21[j20] = uint8(num)
         j20++
      }
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(j20))
      i += copy(dAtA[i:], dAtA21[:j20])
   }
   if m.RcLocation != nil {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
      n22, err22 := m.RcLocation.MarshalTo(dAtA[i:])
      if err22 != nil {
         return 0, err22
      }
      i += n22
   }
   if m.RcCarLocation != nil {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcCarLocation.Size()))
      n23, err23 := m.RcCarLocation.MarshalTo(dAtA[i:])
      if err23 != nil {
         return 0, err23
      }
      i += n23
   }
   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 *PlateIDResult) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -2281,6 +2874,133 @@
   l = len(m.NCarModelConfidence)
   if l > 0 {
      n += 2 + l + sovSdk(uint64(l))
   }
   return n
}

func (m *PlateIDCloud) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.License)
   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.NConfidence != 0 {
      n += 1 + sovSdk(uint64(m.NConfidence))
   }
   if m.NType != 0 {
      n += 1 + sovSdk(uint64(m.NType))
   }
   if m.NDirection != 0 {
      n += 1 + sovSdk(uint64(m.NDirection))
   }
   if m.NCarColor != 0 {
      n += 1 + sovSdk(uint64(m.NCarColor))
   }
   if m.NCarColor1 != 0 {
      n += 1 + sovSdk(uint64(m.NCarColor1))
   }
   if m.NCarBright != 0 {
      n += 1 + sovSdk(uint64(m.NCarBright))
   }
   if m.FrameNo != 0 {
      n += 1 + sovSdk(uint64(m.FrameNo))
   }
   if m.FaceWidth != 0 {
      n += 1 + sovSdk(uint64(m.FaceWidth))
   }
   if m.FaceHeight != 0 {
      n += 1 + sovSdk(uint64(m.FaceHeight))
   }
   if m.GrayFaceFlag != 0 {
      n += 1 + sovSdk(uint64(m.GrayFaceFlag))
   }
   if m.CharNum != 0 {
      n += 1 + sovSdk(uint64(m.CharNum))
   }
   return n
}

func (m *PlateIDVehicle) 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))
   }
   if len(m.NCharConfidence) > 0 {
      l = 0
      for _, e := range m.NCharConfidence {
         l += sovSdk(uint64(e))
      }
      n += 1 + sovSdk(uint64(l)) + 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
}
@@ -4885,6 +5605,890 @@
   }
   return nil
}
func (m *PlateIDCloud) 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: PlateIDCloud: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateIDCloud: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         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 2:
         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 3:
         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 4:
         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 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NDirection", wireType)
         }
         m.NDirection = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NDirection |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarColor", wireType)
         }
         m.NCarColor = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarColor |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 7:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarColor1", wireType)
         }
         m.NCarColor1 = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarColor1 |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 8:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarBright", wireType)
         }
         m.NCarBright = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.NCarBright |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 9:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FrameNo", wireType)
         }
         m.FrameNo = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FrameNo |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 10:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceWidth", wireType)
         }
         m.FaceWidth = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceWidth |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 11:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceHeight", wireType)
         }
         m.FaceHeight = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FaceHeight |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 12:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field GrayFaceFlag", wireType)
         }
         m.GrayFaceFlag = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.GrayFaceFlag |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 13:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field CharNum", wireType)
         }
         m.CharNum = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSdk
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.CharNum |= 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 *PlateIDVehicle) 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: PlateIDVehicle: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateIDVehicle: 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 == 0 {
            var v int32
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowSdk
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               v |= int32(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            m.NCharConfidence = append(m.NCharConfidence, v)
         } else if wireType == 2 {
            var packedLen int
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowSdk
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               packedLen |= int(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            if packedLen < 0 {
               return ErrInvalidLengthSdk
            }
            postIndex := iNdEx + packedLen
            if postIndex < 0 {
               return ErrInvalidLengthSdk
            }
            if postIndex > l {
               return io.ErrUnexpectedEOF
            }
            var elementCount int
            var count int
            for _, integer := range dAtA[iNdEx:postIndex] {
               if integer < 128 {
                  count++
               }
            }
            elementCount = count
            if elementCount != 0 && len(m.NCharConfidence) == 0 {
               m.NCharConfidence = make([]int32, 0, elementCount)
            }
            for iNdEx < postIndex {
               var v int32
               for shift := uint(0); ; shift += 7 {
                  if shift >= 64 {
                     return ErrIntOverflowSdk
                  }
                  if iNdEx >= l {
                     return io.ErrUnexpectedEOF
                  }
                  b := dAtA[iNdEx]
                  iNdEx++
                  v |= int32(b&0x7F) << shift
                  if b < 0x80 {
                     break
                  }
               }
               m.NCharConfidence = append(m.NCharConfidence, v)
            }
         } else {
            return fmt.Errorf("proto: wrong wireType = %d for field NCharConfidence", wireType)
         }
      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 *PlateIDResult) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -4943,7 +6547,7 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Result = append(m.Result, &PlateID{})
         m.Result = append(m.Result, &PlateIDVehicle{})
         if err := m.Result[len(m.Result)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }