add cloud plate detect

zhangmeng

2019-11-19 54e26e896cafc1e63d6626b9eb0f6bfcbf0bbb0b

 sdk.pb.go

@@ -861,14 +861,15 @@
   RcLocation          *Rect  `protobuf:"bytes,8,opt,name=rcLocation,proto3" json:"rcLocation,omitempty"`
   NTime               int32  `protobuf:"varint,9,opt,name=nTime,proto3" json:"nTime,omitempty"`
   NCarBright          int32  `protobuf:"varint,10,opt,name=nCarBright,proto3" json:"nCarBright,omitempty"`
   NCarLogo            int32  `protobuf:"varint,11,opt,name=nCarLogo,proto3" json:"nCarLogo,omitempty"`
   NCarType            int32  `protobuf:"varint,12,opt,name=nCarType,proto3" json:"nCarType,omitempty"`
   PlateBin            []byte `protobuf:"bytes,13,opt,name=plateBin,proto3" json:"plateBin,omitempty"`
   NBinPlateWidth      []byte `protobuf:"bytes,14,opt,name=nBinPlateWidth,proto3" json:"nBinPlateWidth,omitempty"`
   NBinPlateHeight     []byte `protobuf:"bytes,15,opt,name=nBinPlateHeight,proto3" json:"nBinPlateHeight,omitempty"`
   RcLogoLocation      *Rect  `protobuf:"bytes,16,opt,name=rcLogoLocation,proto3" json:"rcLogoLocation,omitempty"`
   NCarModel           []byte `protobuf:"bytes,17,opt,name=nCarModel,proto3" json:"nCarModel,omitempty"`
   NCarModelConfidence []byte `protobuf:"bytes,18,opt,name=nCarModelConfidence,proto3" json:"nCarModelConfidence,omitempty"`
   NCarColor           int32  `protobuf:"varint,11,opt,name=NCarColor,proto3" json:"NCarColor,omitempty"`
   NCarLogo            int32  `protobuf:"varint,12,opt,name=nCarLogo,proto3" json:"nCarLogo,omitempty"`
   NCarType            int32  `protobuf:"varint,13,opt,name=nCarType,proto3" json:"nCarType,omitempty"`
   PlateBin            []byte `protobuf:"bytes,14,opt,name=plateBin,proto3" json:"plateBin,omitempty"`
   NBinPlateWidth      []byte `protobuf:"bytes,15,opt,name=nBinPlateWidth,proto3" json:"nBinPlateWidth,omitempty"`
   NBinPlateHeight     []byte `protobuf:"bytes,16,opt,name=nBinPlateHeight,proto3" json:"nBinPlateHeight,omitempty"`
   RcLogoLocation      *Rect  `protobuf:"bytes,17,opt,name=rcLogoLocation,proto3" json:"rcLogoLocation,omitempty"`
   NCarModel           []byte `protobuf:"bytes,18,opt,name=nCarModel,proto3" json:"nCarModel,omitempty"`
   NCarModelConfidence []byte `protobuf:"bytes,19,opt,name=nCarModelConfidence,proto3" json:"nCarModelConfidence,omitempty"`
}

func (m *PlateID) Reset()         { *m = PlateID{} }
@@ -974,6 +975,13 @@
   return 0
}

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

func (m *PlateID) GetNCarLogo() int32 {
   if m != nil {
      return m.NCarLogo
@@ -1074,6 +1082,191 @@
   return nil
}

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

var xxx_messageInfo_PlateCloudID proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var xxx_messageInfo_PlateCloudIDResult proto.InternalMessageInfo

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

func init() {
   proto.RegisterType((*Image)(nil), "protomsg.Image")
   proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -1089,74 +1282,85 @@
   proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
   proto.RegisterType((*PlateID)(nil), "protomsg.PlateID")
   proto.RegisterType((*PlateIDResult)(nil), "protomsg.PlateIDResult")
   proto.RegisterType((*PlateCloudID)(nil), "protomsg.PlateCloudID")
   proto.RegisterType((*PlateCloudIDResult)(nil), "protomsg.PlateCloudIDResult")
}

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

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

func (m *Image) Marshal() (dAtA []byte, err error) {
@@ -1806,36 +2010,43 @@
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
   }
   if m.NCarLogo != 0 {
   if m.NCarColor != 0 {
      dAtA[i] = 0x58
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
   }
   if m.NCarLogo != 0 {
      dAtA[i] = 0x60
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarLogo))
   }
   if m.NCarType != 0 {
      dAtA[i] = 0x60
      dAtA[i] = 0x68
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarType))
   }
   if len(m.PlateBin) > 0 {
      dAtA[i] = 0x6a
      dAtA[i] = 0x72
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.PlateBin)))
      i += copy(dAtA[i:], m.PlateBin)
   }
   if len(m.NBinPlateWidth) > 0 {
      dAtA[i] = 0x72
      dAtA[i] = 0x7a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateWidth)))
      i += copy(dAtA[i:], m.NBinPlateWidth)
   }
   if len(m.NBinPlateHeight) > 0 {
      dAtA[i] = 0x7a
      dAtA[i] = 0x82
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateHeight)))
      i += copy(dAtA[i:], m.NBinPlateHeight)
   }
   if m.RcLogoLocation != nil {
      dAtA[i] = 0x82
      dAtA[i] = 0x8a
      i++
      dAtA[i] = 0x1
      i++
@@ -1847,7 +2058,7 @@
      i += n18
   }
   if len(m.NCarModel) > 0 {
      dAtA[i] = 0x8a
      dAtA[i] = 0x92
      i++
      dAtA[i] = 0x1
      i++
@@ -1855,7 +2066,7 @@
      i += copy(dAtA[i:], m.NCarModel)
   }
   if len(m.NCarModelConfidence) > 0 {
      dAtA[i] = 0x92
      dAtA[i] = 0x9a
      i++
      dAtA[i] = 0x1
      i++
@@ -1876,6 +2087,125 @@
}

func (m *PlateIDResult) 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 (m *PlateCloudID) 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 *PlateCloudID) 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 *PlateCloudIDResult) 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 *PlateCloudIDResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -2234,6 +2564,9 @@
   if m.NCarBright != 0 {
      n += 1 + sovSdk(uint64(m.NCarBright))
   }
   if m.NCarColor != 0 {
      n += 1 + sovSdk(uint64(m.NCarColor))
   }
   if m.NCarLogo != 0 {
      n += 1 + sovSdk(uint64(m.NCarLogo))
   }
@@ -2250,7 +2583,7 @@
   }
   l = len(m.NBinPlateHeight)
   if l > 0 {
      n += 1 + l + sovSdk(uint64(l))
      n += 2 + l + sovSdk(uint64(l))
   }
   if m.RcLogoLocation != nil {
      l = m.RcLogoLocation.Size()
@@ -2268,6 +2601,71 @@
}

func (m *PlateIDResult) 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 *PlateCloudID) 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 *PlateCloudIDResult) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -4582,6 +4980,25 @@
         }
      case 11:
         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 12:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarLogo", wireType)
         }
         m.NCarLogo = 0
@@ -4599,7 +5016,7 @@
               break
            }
         }
      case 12:
      case 13:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarType", wireType)
         }
@@ -4618,7 +5035,7 @@
               break
            }
         }
      case 13:
      case 14:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PlateBin", wireType)
         }
@@ -4652,7 +5069,7 @@
            m.PlateBin = []byte{}
         }
         iNdEx = postIndex
      case 14:
      case 15:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateWidth", wireType)
         }
@@ -4686,7 +5103,7 @@
            m.NBinPlateWidth = []byte{}
         }
         iNdEx = postIndex
      case 15:
      case 16:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NBinPlateHeight", wireType)
         }
@@ -4720,7 +5137,7 @@
            m.NBinPlateHeight = []byte{}
         }
         iNdEx = postIndex
      case 16:
      case 17:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field RcLogoLocation", wireType)
         }
@@ -4756,7 +5173,7 @@
            return err
         }
         iNdEx = postIndex
      case 17:
      case 18:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarModel", wireType)
         }
@@ -4790,7 +5207,7 @@
            m.NCarModel = []byte{}
         }
         iNdEx = postIndex
      case 18:
      case 19:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NCarModelConfidence", wireType)
         }
@@ -4935,6 +5352,423 @@
   }
   return nil
}
func (m *PlateCloudID) 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: PlateCloudID: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudID: 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 *PlateCloudIDResult) 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: PlateCloudIDResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PlateCloudIDResult: 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, &PlateCloudID{})
         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