add faceId

chenshijun

2020-03-03 5e7d4af757168a629f9fe8af06b1ce5a93a12d06

 sdk.pb.go

@@ -21,7 +21,7 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// Image ipc struct
type Image struct {
@@ -47,7 +47,7 @@
      return xxx_messageInfo_Image.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -129,7 +129,7 @@
      return xxx_messageInfo_FaceAngle.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -198,7 +198,7 @@
      return xxx_messageInfo_ThftResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -278,7 +278,7 @@
      return xxx_messageInfo_FacePos.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -386,7 +386,7 @@
      return xxx_messageInfo_FaceInfo.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -489,7 +489,7 @@
      return xxx_messageInfo_ObjInfo.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -557,7 +557,7 @@
      return xxx_messageInfo_ResultFaceDetect.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -615,7 +615,7 @@
      return xxx_messageInfo_ParamFacePos.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -661,7 +661,7 @@
      return xxx_messageInfo_ResultFaceExtCom.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -719,7 +719,7 @@
      return xxx_messageInfo_ParamFaceFeature.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -764,7 +764,7 @@
      return xxx_messageInfo_ParamYoloObj.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -810,7 +810,7 @@
      return xxx_messageInfo_SoInfo.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -887,7 +887,7 @@
      return xxx_messageInfo_PlateID.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1070,7 +1070,7 @@
      return xxx_messageInfo_PlateIDCloud.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1216,7 +1216,7 @@
      return xxx_messageInfo_PlateIDVehicle.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1388,7 +1388,7 @@
      return xxx_messageInfo_PlateIDResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1437,7 +1437,7 @@
      return xxx_messageInfo_HumanTrack.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1516,7 +1516,7 @@
      return xxx_messageInfo_HumanTrackResult.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -1659,7 +1659,7 @@
func (m *Image) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -1667,58 +1667,50 @@
}

func (m *Image) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Image) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Cid) > 0 {
      i -= len(m.Cid)
      copy(dAtA[i:], m.Cid)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Cid)))
      i--
      dAtA[i] = 0x32
   }
   if m.Id != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Id))
      i--
      dAtA[i] = 0x28
   }
   if len(m.Timestamp) > 0 {
      i -= len(m.Timestamp)
      copy(dAtA[i:], m.Timestamp)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Timestamp)))
      i--
      dAtA[i] = 0x22
   }
   if len(m.Data) > 0 {
      i -= len(m.Data)
      copy(dAtA[i:], m.Data)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Data)))
      i--
      dAtA[i] = 0x1a
   if m.Width != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Width))
   }
   if m.Height != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Height))
      i--
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Height))
   }
   if m.Width != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Width))
      i--
      dAtA[i] = 0x8
   if len(m.Data) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Data)))
      i += copy(dAtA[i:], m.Data)
   }
   return len(dAtA) - i, nil
   if len(m.Timestamp) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Timestamp)))
      i += copy(dAtA[i:], m.Timestamp)
   }
   if m.Id != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Id))
   }
   if len(m.Cid) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Cid)))
      i += copy(dAtA[i:], m.Cid)
   }
   return i, nil
}

func (m *FaceAngle) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -1726,43 +1718,38 @@
}

func (m *FaceAngle) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FaceAngle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.Confidence != 0 {
      i -= 4
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
      i--
      dAtA[i] = 0x25
   }
   if m.Roll != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Roll))
      i--
      dAtA[i] = 0x18
   if m.Yaw != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Yaw))
   }
   if m.Pitch != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Pitch))
      i--
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Pitch))
   }
   if m.Yaw != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Yaw))
      i--
      dAtA[i] = 0x8
   if m.Roll != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Roll))
   }
   return len(dAtA) - i, nil
   if m.Confidence != 0 {
      dAtA[i] = 0x25
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
      i += 4
   }
   return i, nil
}

func (m *ThftResult) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -1770,47 +1757,42 @@
}

func (m *ThftResult) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThftResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.Smile != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Smile))
      i--
      dAtA[i] = 0x28
   }
   if m.Beauty != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Beauty))
      i--
      dAtA[i] = 0x20
   }
   if m.Race != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Race))
      i--
      dAtA[i] = 0x18
   if m.Gender != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Gender))
   }
   if m.Age != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Age))
      i--
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Age))
   }
   if m.Gender != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Gender))
      i--
      dAtA[i] = 0x8
   if m.Race != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Race))
   }
   return len(dAtA) - i, nil
   if m.Beauty != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Beauty))
   }
   if m.Smile != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Smile))
   }
   return i, nil
}

func (m *FacePos) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -1818,111 +1800,93 @@
}

func (m *FacePos) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FacePos) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.FaceID != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
      i--
      dAtA[i] = 0x48
   }
   if len(m.FacialData) > 0 {
      i -= len(m.FacialData)
      copy(dAtA[i:], m.FacialData)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
      i--
      dAtA[i] = 0x42
   }
   if m.Quality != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Quality))
      i--
      dAtA[i] = 0x38
   }
   if m.FAngle != nil {
      {
         size, err := m.FAngle.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
   if m.RcFace != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcFace.Size()))
      n1, err1 := m.RcFace.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i--
      dAtA[i] = 0x32
   }
   if m.PtNose != nil {
      {
         size, err := m.PtNose.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x2a
   }
   if m.PtMouth != nil {
      {
         size, err := m.PtMouth.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x22
   }
   if m.PtRightEye != nil {
      {
         size, err := m.PtRightEye.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x1a
      i += n1
   }
   if m.PtLeftEye != nil {
      {
         size, err := m.PtLeftEye.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x12
   }
   if m.RcFace != nil {
      {
         size, err := m.RcFace.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
      n2, err2 := m.PtLeftEye.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      }
      i--
      dAtA[i] = 0xa
      i += n2
   }
   return len(dAtA) - i, nil
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
      n3, err3 := m.PtRightEye.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n3
   }
   if m.PtMouth != nil {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
      n4, err4 := m.PtMouth.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   if m.PtNose != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtNose.Size()))
      n5, err5 := m.PtNose.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FAngle.Size()))
      n6, err6 := m.FAngle.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      }
      i += n6
   }
   if m.Quality != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Quality))
   }
   if len(m.FacialData) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
      i += copy(dAtA[i:], m.FacialData)
   }
   if m.FaceID != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
   }
   return i, nil
}

func (m *FaceInfo) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -1930,111 +1894,93 @@
}

func (m *FaceInfo) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FaceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.FaceID != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
      i--
      dAtA[i] = 0x48
   }
   if len(m.FacialData) > 0 {
      i -= len(m.FacialData)
      copy(dAtA[i:], m.FacialData)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
      i--
      dAtA[i] = 0x42
   }
   if m.Quality != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Quality))
      i--
      dAtA[i] = 0x38
   }
   if m.FAngle != nil {
      {
         size, err := m.FAngle.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
   if m.RcFace != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcFace.Size()))
      n7, err7 := m.RcFace.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      }
      i--
      dAtA[i] = 0x32
   }
   if m.PtNose != nil {
      {
         size, err := m.PtNose.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x2a
   }
   if m.PtMouth != nil {
      {
         size, err := m.PtMouth.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x22
   }
   if m.PtRightEye != nil {
      {
         size, err := m.PtRightEye.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x1a
      i += n7
   }
   if m.PtLeftEye != nil {
      {
         size, err := m.PtLeftEye.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x12
   }
   if m.RcFace != nil {
      {
         size, err := m.RcFace.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtLeftEye.Size()))
      n8, err8 := m.PtLeftEye.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      }
      i--
      dAtA[i] = 0xa
      i += n8
   }
   return len(dAtA) - i, nil
   if m.PtRightEye != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtRightEye.Size()))
      n9, err9 := m.PtRightEye.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n9
   }
   if m.PtMouth != nil {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtMouth.Size()))
      n10, err10 := m.PtMouth.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += n10
   }
   if m.PtNose != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.PtNose.Size()))
      n11, err11 := m.PtNose.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      }
      i += n11
   }
   if m.FAngle != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FAngle.Size()))
      n12, err12 := m.FAngle.MarshalTo(dAtA[i:])
      if err12 != nil {
         return 0, err12
      }
      i += n12
   }
   if m.Quality != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Quality))
   }
   if len(m.FacialData) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.FacialData)))
      i += copy(dAtA[i:], m.FacialData)
   }
   if m.FaceID != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.FaceID))
   }
   return i, nil
}

func (m *ObjInfo) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2042,50 +1988,43 @@
}

func (m *ObjInfo) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ObjInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.ObjID != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.ObjID))
      i--
      dAtA[i] = 0x20
   }
   if m.Prob != 0 {
      i -= 4
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
      i--
      dAtA[i] = 0x1d
   if m.RcObj != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcObj.Size()))
      n13, err13 := m.RcObj.MarshalTo(dAtA[i:])
      if err13 != nil {
         return 0, err13
      }
      i += n13
   }
   if m.Typ != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Typ))
      i--
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Typ))
   }
   if m.RcObj != nil {
      {
         size, err := m.RcObj.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0xa
   if m.Prob != 0 {
      dAtA[i] = 0x1d
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
      i += 4
   }
   return len(dAtA) - i, nil
   if m.ObjID != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.ObjID))
   }
   return i, nil
}

func (m *ResultFaceDetect) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2093,53 +2032,43 @@
}

func (m *ResultFaceDetect) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResultFaceDetect) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Feats) > 0 {
      i -= len(m.Feats)
      copy(dAtA[i:], m.Feats)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i--
      dAtA[i] = 0x1a
   if m.Pos != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
      n14, err14 := m.Pos.MarshalTo(dAtA[i:])
      if err14 != nil {
         return 0, err14
      }
      i += n14
   }
   if m.Result != nil {
      {
         size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x12
   }
   if m.Pos != nil {
      {
         size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Result.Size()))
      n15, err15 := m.Result.MarshalTo(dAtA[i:])
      if err15 != nil {
         return 0, err15
      }
      i--
      dAtA[i] = 0xa
      i += n15
   }
   return len(dAtA) - i, nil
   if len(m.Feats) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i += copy(dAtA[i:], m.Feats)
   }
   return i, nil
}

func (m *ParamFacePos) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2147,36 +2076,29 @@
}

func (m *ParamFacePos) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParamFacePos) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Faces) > 0 {
      for iNdEx := len(m.Faces) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Faces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSdk(dAtA, i, uint64(size))
         }
         i--
      for _, msg := range m.Faces {
         dAtA[i] = 0xa
         i++
         i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *ResultFaceExtCom) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2184,48 +2106,39 @@
}

func (m *ResultFaceExtCom) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResultFaceExtCom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.Pos != nil {
      {
         size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x1a
   if len(m.Feats) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i += copy(dAtA[i:], m.Feats)
   }
   if len(m.Comp) > 0 {
      i -= len(m.Comp)
      copy(dAtA[i:], m.Comp)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Comp)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Comp)))
      i += copy(dAtA[i:], m.Comp)
   }
   if len(m.Feats) > 0 {
      i -= len(m.Feats)
      copy(dAtA[i:], m.Feats)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feats)))
      i--
      dAtA[i] = 0xa
   if m.Pos != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Pos.Size()))
      n16, err16 := m.Pos.MarshalTo(dAtA[i:])
      if err16 != nil {
         return 0, err16
      }
      i += n16
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *ParamFaceFeature) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2233,36 +2146,29 @@
}

func (m *ParamFaceFeature) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParamFaceFeature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ExtComp) > 0 {
      for iNdEx := len(m.ExtComp) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.ExtComp[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSdk(dAtA, i, uint64(size))
         }
         i--
      for _, msg := range m.ExtComp {
         dAtA[i] = 0x12
         i++
         i = encodeVarintSdk(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *ParamYoloObj) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2270,36 +2176,29 @@
}

func (m *ParamYoloObj) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ParamYoloObj) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Infos) > 0 {
      for iNdEx := len(m.Infos) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Infos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSdk(dAtA, i, uint64(size))
         }
         i--
      for _, msg := range m.Infos {
         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 len(dAtA) - i, nil
   return i, nil
}

func (m *SoInfo) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2307,43 +2206,35 @@
}

func (m *SoInfo) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SoInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.SoName) > 0 {
      i -= len(m.SoName)
      copy(dAtA[i:], m.SoName)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SoName)))
      i--
      dAtA[i] = 0x1a
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.SdkId) > 0 {
      i -= len(m.SdkId)
      copy(dAtA[i:], m.SdkId)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkId)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SdkId)))
      i += copy(dAtA[i:], m.SdkId)
   }
   if len(m.Id) > 0 {
      i -= len(m.Id)
      copy(dAtA[i:], m.Id)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Id)))
      i--
      dAtA[i] = 0xa
   if len(m.SoName) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.SoName)))
      i += copy(dAtA[i:], m.SoName)
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *PlateID) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2351,153 +2242,137 @@
}

func (m *PlateID) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PlateID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.NCarModelConfidence) > 0 {
      i -= len(m.NCarModelConfidence)
      copy(dAtA[i:], m.NCarModelConfidence)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModelConfidence)))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x9a
   }
   if len(m.NCarModel) > 0 {
      i -= len(m.NCarModel)
      copy(dAtA[i:], m.NCarModel)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModel)))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x92
   }
   if m.RcLogoLocation != nil {
      {
         size, err := m.RcLogoLocation.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x8a
   }
   if len(m.NBinPlateHeight) > 0 {
      i -= len(m.NBinPlateHeight)
      copy(dAtA[i:], m.NBinPlateHeight)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateHeight)))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x82
   }
   if len(m.NBinPlateWidth) > 0 {
      i -= len(m.NBinPlateWidth)
      copy(dAtA[i:], m.NBinPlateWidth)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateWidth)))
      i--
      dAtA[i] = 0x7a
   }
   if len(m.PlateBin) > 0 {
      i -= len(m.PlateBin)
      copy(dAtA[i:], m.PlateBin)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.PlateBin)))
      i--
      dAtA[i] = 0x72
   }
   if m.NCarType != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarType))
      i--
      dAtA[i] = 0x68
   }
   if m.NCarLogo != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarLogo))
      i--
      dAtA[i] = 0x60
   }
   if m.NCarColor != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarColor))
      i--
      dAtA[i] = 0x58
   }
   if m.NCarBright != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
      i--
      dAtA[i] = 0x50
   }
   if m.NTime != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NTime))
      i--
      dAtA[i] = 0x48
   }
   if m.RcLocation != nil {
      {
         size, err := m.RcLocation.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x42
   }
   if m.NDirection != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NDirection))
      i--
      dAtA[i] = 0x38
   }
   if m.NBright != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NBright))
      i--
      dAtA[i] = 0x30
   }
   if m.NConfidence != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
      i--
      dAtA[i] = 0x28
   }
   if m.NType != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
      i--
      dAtA[i] = 0x20
   }
   if m.NColor != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
      i--
      dAtA[i] = 0x18
   if len(m.License) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
      i += copy(dAtA[i:], m.License)
   }
   if len(m.Color) > 0 {
      i -= len(m.Color)
      copy(dAtA[i:], m.Color)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Color)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Color)))
      i += copy(dAtA[i:], m.Color)
   }
   if len(m.License) > 0 {
      i -= len(m.License)
      copy(dAtA[i:], m.License)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
      i--
      dAtA[i] = 0xa
   if m.NColor != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
   }
   return len(dAtA) - i, nil
   if m.NType != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
   }
   if m.NConfidence != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
   }
   if m.NBright != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NBright))
   }
   if m.NDirection != 0 {
      dAtA[i] = 0x38
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NDirection))
   }
   if m.RcLocation != nil {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcLocation.Size()))
      n17, err17 := m.RcLocation.MarshalTo(dAtA[i:])
      if err17 != nil {
         return 0, err17
      }
      i += n17
   }
   if m.NTime != 0 {
      dAtA[i] = 0x48
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NTime))
   }
   if m.NCarBright != 0 {
      dAtA[i] = 0x50
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarBright))
   }
   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] = 0x68
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCarType))
   }
   if len(m.PlateBin) > 0 {
      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] = 0x7a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NBinPlateWidth)))
      i += copy(dAtA[i:], m.NBinPlateWidth)
   }
   if len(m.NBinPlateHeight) > 0 {
      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] = 0x8a
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcLogoLocation.Size()))
      n18, err18 := m.RcLogoLocation.MarshalTo(dAtA[i:])
      if err18 != nil {
         return 0, err18
      }
      i += n18
   }
   if len(m.NCarModel) > 0 {
      dAtA[i] = 0x92
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModel)))
      i += copy(dAtA[i:], m.NCarModel)
   }
   if len(m.NCarModelConfidence) > 0 {
      dAtA[i] = 0x9a
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.NCarModelConfidence)))
      i += copy(dAtA[i:], m.NCarModelConfidence)
   }
   return i, nil
}

func (m *PlateIDCloud) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2505,96 +2380,88 @@
}

func (m *PlateIDCloud) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *PlateIDVehicle) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PlateIDVehicle) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.NVehicleColor2 != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor2))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x98
   if m.NPlateFlag != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NPlateFlag))
   }
   if m.NVehicleColor1 != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleColor1))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x90
   if m.NColor != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
   }
   if m.NVehicleBright != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleBright))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x88
   if m.NType != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
   }
   if m.NVehicleSubModel != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NVehicleSubModel))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x80
   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.FConfdence != 0 {
      i -= 4
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FConfdence))))
      i--
      dAtA[i] = 0x7d
   if m.NConfidence != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
   }
   if m.FvdConf != 0 {
      i -= 4
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.FvdConf))))
      i--
      dAtA[i] = 0x75
   }
   if len(m.VehicleType1) > 0 {
      i -= len(m.VehicleType1)
      copy(dAtA[i:], m.VehicleType1)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType1)))
      i--
      dAtA[i] = 0x6a
   }
   if len(m.VehicleSub) > 0 {
      i -= len(m.VehicleSub)
      copy(dAtA[i:], m.VehicleSub)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleSub)))
      i--
      dAtA[i] = 0x62
   }
   if len(m.VehicleBrand) > 0 {
      i -= len(m.VehicleBrand)
      copy(dAtA[i:], m.VehicleBrand)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleBrand)))
      i--
      dAtA[i] = 0x5a
   }
   if len(m.VehicleType) > 0 {
      i -= len(m.VehicleType)
      copy(dAtA[i:], m.VehicleType)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType)))
      i--
      dAtA[i] = 0x52
   }
   if m.RcCarLocation != nil {
      {
         size, err := m.RcCarLocation.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x4a
   }
   if m.RcLocation != nil {
      {
         size, err := m.RcLocation.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
      }
      i--
      dAtA[i] = 0x42
   if m.NCharNum != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
   }
   if len(m.NCharConfidence) > 0 {
      dAtA23 := make([]byte, len(m.NCharConfidence)*10)
      var j22 int
      dAtA21 := make([]byte, len(m.NCharConfidence)*10)
      var j20 int
      for _, num1 := range m.NCharConfidence {
         num := uint64(num1)
         for num >= 1<<7 {
            dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
            dAtA21[j20] = uint8(uint64(num)&0x7f | 0x80)
            num >>= 7
            j22++
            j20++
         }
         dAtA23[j22] = uint8(num)
         j22++
         dAtA21[j20] = uint8(num)
         j20++
      }
      i -= j22
      copy(dAtA[i:], dAtA23[:j22])
      i = encodeVarintSdk(dAtA, i, uint64(j22))
      i--
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(j20))
      i += copy(dAtA[i:], dAtA21[:j20])
   }
   if m.NCharNum != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NCharNum))
      i--
      dAtA[i] = 0x30
   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.NConfidence != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NConfidence))
      i--
      dAtA[i] = 0x28
   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.License) > 0 {
      i -= len(m.License)
      copy(dAtA[i:], m.License)
      i = encodeVarintSdk(dAtA, i, uint64(len(m.License)))
      i--
      dAtA[i] = 0x22
   if len(m.VehicleType) > 0 {
      dAtA[i] = 0x52
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType)))
      i += copy(dAtA[i:], m.VehicleType)
   }
   if m.NType != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NType))
      i--
      dAtA[i] = 0x18
   if len(m.VehicleBrand) > 0 {
      dAtA[i] = 0x5a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleBrand)))
      i += copy(dAtA[i:], m.VehicleBrand)
   }
   if m.NColor != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NColor))
      i--
      dAtA[i] = 0x10
   if len(m.VehicleSub) > 0 {
      dAtA[i] = 0x62
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleSub)))
      i += copy(dAtA[i:], m.VehicleSub)
   }
   if m.NPlateFlag != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.NPlateFlag))
      i--
      dAtA[i] = 0x8
   if len(m.VehicleType1) > 0 {
      dAtA[i] = 0x6a
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.VehicleType1)))
      i += copy(dAtA[i:], m.VehicleType1)
   }
   return len(dAtA) - i, nil
   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)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2768,36 +2620,29 @@
}

func (m *PlateIDResult) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PlateIDResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Result) > 0 {
      for iNdEx := len(m.Result) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Result[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSdk(dAtA, i, uint64(size))
         }
         i--
      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 len(dAtA) - i, nil
   return i, nil
}

func (m *HumanTrack) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2805,65 +2650,58 @@
}

func (m *HumanTrack) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HumanTrack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Feature) > 0 {
      for iNdEx := len(m.Feature) - 1; iNdEx >= 0; iNdEx-- {
         f24 := math.Float32bits(float32(m.Feature[iNdEx]))
         i -= 4
         encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f24))
   if m.RcHuman != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.RcHuman.Size()))
      n24, err24 := m.RcHuman.MarshalTo(dAtA[i:])
      if err24 != nil {
         return 0, err24
      }
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feature)*4))
      i--
      dAtA[i] = 0x32
   }
   if m.Id != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Id))
      i--
      dAtA[i] = 0x28
   }
   if m.Y != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.Y))
      i--
      dAtA[i] = 0x20
   }
   if m.X != 0 {
      i = encodeVarintSdk(dAtA, i, uint64(m.X))
      i--
      dAtA[i] = 0x18
      i += n24
   }
   if m.Confidence != 0 {
      i -= 4
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
      i--
      dAtA[i] = 0x15
      i++
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
      i += 4
   }
   if m.RcHuman != nil {
      {
         size, err := m.RcHuman.MarshalToSizedBuffer(dAtA[:i])
         if err != nil {
            return 0, err
         }
         i -= size
         i = encodeVarintSdk(dAtA, i, uint64(size))
   if m.X != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.X))
   }
   if m.Y != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Y))
   }
   if m.Id != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSdk(dAtA, i, uint64(m.Id))
   }
   if len(m.Feature) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSdk(dAtA, i, uint64(len(m.Feature)*4))
      for _, num := range m.Feature {
         f25 := math.Float32bits(float32(num))
         encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f25))
         i += 4
      }
      i--
      dAtA[i] = 0xa
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *HumanTrackResult) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -2871,42 +2709,33 @@
}

func (m *HumanTrackResult) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HumanTrackResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Result) > 0 {
      for iNdEx := len(m.Result) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Result[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSdk(dAtA, i, uint64(size))
         }
         i--
      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 len(dAtA) - i, nil
   return i, nil
}

func encodeVarintSdk(dAtA []byte, offset int, v uint64) int {
   offset -= sovSdk(v)
   base := offset
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return base
   return offset + 1
}
func (m *Image) Size() (n int) {
   if m == nil {
@@ -7309,7 +7138,6 @@
func skipSdk(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0
   depth := 0
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
@@ -7341,8 +7169,10 @@
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
@@ -7363,30 +7193,55 @@
            return 0, ErrInvalidLengthSdk
         }
         iNdEx += length
      case 3:
         depth++
      case 4:
         if depth == 0 {
            return 0, ErrUnexpectedEndOfGroupSdk
         if iNdEx < 0 {
            return 0, ErrInvalidLengthSdk
         }
         depth--
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowSdk
               }
               if iNdEx >= l {
                  return 0, io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               innerWire |= (uint64(b) & 0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            innerWireType := int(innerWire & 0x7)
            if innerWireType == 4 {
               break
            }
            next, err := skipSdk(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthSdk
            }
         }
         return iNdEx, nil
      case 4:
         return iNdEx, nil
      case 5:
         iNdEx += 4
         return iNdEx, nil
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
      if iNdEx < 0 {
         return 0, ErrInvalidLengthSdk
      }
      if depth == 0 {
         return iNdEx, nil
      }
   }
   return 0, io.ErrUnexpectedEOF
   panic("unreachable")
}

var (
   ErrInvalidLengthSdk        = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowSdk          = fmt.Errorf("proto: integer overflow")
   ErrUnexpectedEndOfGroupSdk = fmt.Errorf("proto: unexpected end of group")
   ErrInvalidLengthSdk = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowSdk   = fmt.Errorf("proto: integer overflow")
)