"""
Autogenerated python message buffer code.
Source: clad/types/imageTypes.clad
Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/types/imageTypes.clad
"""

from __future__ import absolute_import
from __future__ import print_function

def _modify_path():
  import inspect, os, sys
  search_paths = [
    '../..',
    '../../../../victor-clad/tools/message-buffers/support/python',
  ]
  currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe())))
  for search_path in search_paths:
    search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path))))
    if search_path not in sys.path:
      sys.path.insert(0, search_path)
_modify_path()

import msgbuffers

Anki = msgbuffers.Namespace()
Anki.Vector = msgbuffers.Namespace()
Anki.Vision = msgbuffers.Namespace()

from clad.types.imageFormats import Anki as _Anki
Anki.update(_Anki.deep_clone())

class ImageSendMode(object):
  "Automatically-generated uint_8 enumeration."
  Off                      = 0
  Stream                   = 1
  SingleShot               = 2
  SingleShotWithSensorData = 3

Anki.Vector.ImageSendMode = ImageSendMode
del ImageSendMode


class ImageConstants(object):
  "Automatically-generated uint_32 enumeration."
  IMAGE_CHUNK_SIZE = 1200

Anki.Vector.ImageConstants = ImageConstants
del ImageConstants


class ImageChunk(object):
  "Generated message-passing message."

  __slots__ = (
    '_frameTimeStamp',  # uint_32
    '_imageId',         # uint_32
    '_width',           # uint_16
    '_height',          # uint_16
    '_imageEncoding',   # Anki.Vision.ImageEncoding
    '_displayIndex',    # uint_8
    '_imageChunkCount', # uint_8
    '_chunkId',         # uint_8
    '_data',            # uint_8[uint_16]
  )

  @property
  def frameTimeStamp(self):
    "uint_32 frameTimeStamp struct property."
    return self._frameTimeStamp

  @frameTimeStamp.setter
  def frameTimeStamp(self, value):
    self._frameTimeStamp = msgbuffers.validate_integer(
      'ImageChunk.frameTimeStamp', value, 0, 4294967295)

  @property
  def imageId(self):
    "uint_32 imageId struct property."
    return self._imageId

  @imageId.setter
  def imageId(self, value):
    self._imageId = msgbuffers.validate_integer(
      'ImageChunk.imageId', value, 0, 4294967295)

  @property
  def width(self):
    "uint_16 width struct property."
    return self._width

  @width.setter
  def width(self, value):
    self._width = msgbuffers.validate_integer(
      'ImageChunk.width', value, 0, 65535)

  @property
  def height(self):
    "uint_16 height struct property."
    return self._height

  @height.setter
  def height(self, value):
    self._height = msgbuffers.validate_integer(
      'ImageChunk.height', value, 0, 65535)

  @property
  def imageEncoding(self):
    "Anki.Vision.ImageEncoding imageEncoding struct property."
    return self._imageEncoding

  @imageEncoding.setter
  def imageEncoding(self, value):
    self._imageEncoding = msgbuffers.validate_integer(
      'ImageChunk.imageEncoding', value, 0, 255)

  @property
  def displayIndex(self):
    "uint_8 displayIndex struct property."
    return self._displayIndex

  @displayIndex.setter
  def displayIndex(self, value):
    self._displayIndex = msgbuffers.validate_integer(
      'ImageChunk.displayIndex', value, 0, 255)

  @property
  def imageChunkCount(self):
    "uint_8 imageChunkCount struct property."
    return self._imageChunkCount

  @imageChunkCount.setter
  def imageChunkCount(self, value):
    self._imageChunkCount = msgbuffers.validate_integer(
      'ImageChunk.imageChunkCount', value, 0, 255)

  @property
  def chunkId(self):
    "uint_8 chunkId struct property."
    return self._chunkId

  @chunkId.setter
  def chunkId(self, value):
    self._chunkId = msgbuffers.validate_integer(
      'ImageChunk.chunkId', value, 0, 255)

  @property
  def data(self):
    "uint_8[uint_16] data struct property."
    return self._data

  @data.setter
  def data(self, value):
    self._data = msgbuffers.validate_varray(
      'ImageChunk.data', value, 65535,
      lambda name, value_inner: msgbuffers.validate_integer(
        name, value_inner, 0, 255))

  def __init__(self, frameTimeStamp=0, imageId=0, width=0, height=0, imageEncoding=Anki.Vision.ImageEncoding.NoneImageEncoding, displayIndex=0, imageChunkCount=0, chunkId=0, data=()):
    self.frameTimeStamp = frameTimeStamp
    self.imageId = imageId
    self.width = width
    self.height = height
    self.imageEncoding = imageEncoding
    self.displayIndex = displayIndex
    self.imageChunkCount = imageChunkCount
    self.chunkId = chunkId
    self.data = data

  @classmethod
  def unpack(cls, buffer):
    "Reads a new ImageChunk from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('ImageChunk.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new ImageChunk from the given BinaryReader."
    _frameTimeStamp = reader.read('I')
    _imageId = reader.read('I')
    _width = reader.read('H')
    _height = reader.read('H')
    _imageEncoding = reader.read('B')
    _displayIndex = reader.read('B')
    _imageChunkCount = reader.read('B')
    _chunkId = reader.read('B')
    _data = reader.read_varray('B', 'H')
    return cls(_frameTimeStamp, _imageId, _width, _height, _imageEncoding, _displayIndex, _imageChunkCount, _chunkId, _data)

  def pack(self):
    "Writes the current ImageChunk, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current ImageChunk to the given BinaryWriter."
    writer.write(self._frameTimeStamp, 'I')
    writer.write(self._imageId, 'I')
    writer.write(self._width, 'H')
    writer.write(self._height, 'H')
    writer.write(self._imageEncoding, 'B')
    writer.write(self._displayIndex, 'B')
    writer.write(self._imageChunkCount, 'B')
    writer.write(self._chunkId, 'B')
    writer.write_varray(self._data, 'B', 'H')

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._frameTimeStamp == other._frameTimeStamp and
        self._imageId == other._imageId and
        self._width == other._width and
        self._height == other._height and
        self._imageEncoding == other._imageEncoding and
        self._displayIndex == other._displayIndex and
        self._imageChunkCount == other._imageChunkCount and
        self._chunkId == other._chunkId and
        self._data == other._data)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._frameTimeStamp, 'I') +
      msgbuffers.size(self._imageId, 'I') +
      msgbuffers.size(self._width, 'H') +
      msgbuffers.size(self._height, 'H') +
      msgbuffers.size(self._imageEncoding, 'B') +
      msgbuffers.size(self._displayIndex, 'B') +
      msgbuffers.size(self._imageChunkCount, 'B') +
      msgbuffers.size(self._chunkId, 'B') +
      msgbuffers.size_varray(self._data, 'B', 'H'))

  def __str__(self):
    return '{type}(frameTimeStamp={frameTimeStamp}, imageId={imageId}, width={width}, height={height}, imageEncoding={imageEncoding}, displayIndex={displayIndex}, imageChunkCount={imageChunkCount}, chunkId={chunkId}, data={data})'.format(
      type=type(self).__name__,
      frameTimeStamp=self._frameTimeStamp,
      imageId=self._imageId,
      width=self._width,
      height=self._height,
      imageEncoding=self._imageEncoding,
      displayIndex=self._displayIndex,
      imageChunkCount=self._imageChunkCount,
      chunkId=self._chunkId,
      data=msgbuffers.shorten_sequence(self._data))

  def __repr__(self):
    return '{type}(frameTimeStamp={frameTimeStamp}, imageId={imageId}, width={width}, height={height}, imageEncoding={imageEncoding}, displayIndex={displayIndex}, imageChunkCount={imageChunkCount}, chunkId={chunkId}, data={data})'.format(
      type=type(self).__name__,
      frameTimeStamp=repr(self._frameTimeStamp),
      imageId=repr(self._imageId),
      width=repr(self._width),
      height=repr(self._height),
      imageEncoding=repr(self._imageEncoding),
      displayIndex=repr(self._displayIndex),
      imageChunkCount=repr(self._imageChunkCount),
      chunkId=repr(self._chunkId),
      data=repr(self._data))

Anki.Vector.ImageChunk = ImageChunk
del ImageChunk


class CameraCalibration(object):
  "Generated message-passing message."

  __slots__ = (
    '_focalLength_x', # float_32
    '_focalLength_y', # float_32
    '_center_x',      # float_32
    '_center_y',      # float_32
    '_skew',          # float_32
    '_nrows',         # uint_16
    '_ncols',         # uint_16
    '_distCoeffs',    # float_32[8]
  )

  @property
  def focalLength_x(self):
    "float_32 focalLength_x struct property."
    return self._focalLength_x

  @focalLength_x.setter
  def focalLength_x(self, value):
    self._focalLength_x = msgbuffers.validate_float(
      'CameraCalibration.focalLength_x', value, 'f')

  @property
  def focalLength_y(self):
    "float_32 focalLength_y struct property."
    return self._focalLength_y

  @focalLength_y.setter
  def focalLength_y(self, value):
    self._focalLength_y = msgbuffers.validate_float(
      'CameraCalibration.focalLength_y', value, 'f')

  @property
  def center_x(self):
    "float_32 center_x struct property."
    return self._center_x

  @center_x.setter
  def center_x(self, value):
    self._center_x = msgbuffers.validate_float(
      'CameraCalibration.center_x', value, 'f')

  @property
  def center_y(self):
    "float_32 center_y struct property."
    return self._center_y

  @center_y.setter
  def center_y(self, value):
    self._center_y = msgbuffers.validate_float(
      'CameraCalibration.center_y', value, 'f')

  @property
  def skew(self):
    "float_32 skew struct property."
    return self._skew

  @skew.setter
  def skew(self, value):
    self._skew = msgbuffers.validate_float(
      'CameraCalibration.skew', value, 'f')

  @property
  def nrows(self):
    "uint_16 nrows struct property."
    return self._nrows

  @nrows.setter
  def nrows(self, value):
    self._nrows = msgbuffers.validate_integer(
      'CameraCalibration.nrows', value, 0, 65535)

  @property
  def ncols(self):
    "uint_16 ncols struct property."
    return self._ncols

  @ncols.setter
  def ncols(self, value):
    self._ncols = msgbuffers.validate_integer(
      'CameraCalibration.ncols', value, 0, 65535)

  @property
  def distCoeffs(self):
    "float_32[8] distCoeffs struct property."
    return self._distCoeffs

  @distCoeffs.setter
  def distCoeffs(self, value):
    self._distCoeffs = msgbuffers.validate_farray(
      'CameraCalibration.distCoeffs', value, 8,
      lambda name, value_inner: msgbuffers.validate_float(
        name, value_inner, 'f'))

  def __init__(self, focalLength_x=0.0, focalLength_y=0.0, center_x=0.0, center_y=0.0, skew=0.0, nrows=0, ncols=0, distCoeffs=(0.0,) * 8):
    self.focalLength_x = focalLength_x
    self.focalLength_y = focalLength_y
    self.center_x = center_x
    self.center_y = center_y
    self.skew = skew
    self.nrows = nrows
    self.ncols = ncols
    self.distCoeffs = distCoeffs

  @classmethod
  def unpack(cls, buffer):
    "Reads a new CameraCalibration from the given buffer."
    reader = msgbuffers.BinaryReader(buffer)
    value = cls.unpack_from(reader)
    if reader.tell() != len(reader):
      raise msgbuffers.ReadError(
        ('CameraCalibration.unpack received a buffer of length {length}, ' +
        'but only {position} bytes were read.').format(
        length=len(reader), position=reader.tell()))
    return value

  @classmethod
  def unpack_from(cls, reader):
    "Reads a new CameraCalibration from the given BinaryReader."
    _focalLength_x = reader.read('f')
    _focalLength_y = reader.read('f')
    _center_x = reader.read('f')
    _center_y = reader.read('f')
    _skew = reader.read('f')
    _nrows = reader.read('H')
    _ncols = reader.read('H')
    _distCoeffs = reader.read_farray('f', 8)
    return cls(_focalLength_x, _focalLength_y, _center_x, _center_y, _skew, _nrows, _ncols, _distCoeffs)

  def pack(self):
    "Writes the current CameraCalibration, returning bytes."
    writer = msgbuffers.BinaryWriter()
    self.pack_to(writer)
    return writer.dumps()

  def pack_to(self, writer):
    "Writes the current CameraCalibration to the given BinaryWriter."
    writer.write(self._focalLength_x, 'f')
    writer.write(self._focalLength_y, 'f')
    writer.write(self._center_x, 'f')
    writer.write(self._center_y, 'f')
    writer.write(self._skew, 'f')
    writer.write(self._nrows, 'H')
    writer.write(self._ncols, 'H')
    writer.write_farray(self._distCoeffs, 'f', 8)

  def __eq__(self, other):
    if type(self) is type(other):
      return (self._focalLength_x == other._focalLength_x and
        self._focalLength_y == other._focalLength_y and
        self._center_x == other._center_x and
        self._center_y == other._center_y and
        self._skew == other._skew and
        self._nrows == other._nrows and
        self._ncols == other._ncols and
        self._distCoeffs == other._distCoeffs)
    else:
      return NotImplemented

  def __ne__(self, other):
    if type(self) is type(other):
      return not self.__eq__(other)
    else:
      return NotImplemented

  def __len__(self):
    return (msgbuffers.size(self._focalLength_x, 'f') +
      msgbuffers.size(self._focalLength_y, 'f') +
      msgbuffers.size(self._center_x, 'f') +
      msgbuffers.size(self._center_y, 'f') +
      msgbuffers.size(self._skew, 'f') +
      msgbuffers.size(self._nrows, 'H') +
      msgbuffers.size(self._ncols, 'H') +
      msgbuffers.size_farray(self._distCoeffs, 'f', 8))

  def __str__(self):
    return '{type}(focalLength_x={focalLength_x}, focalLength_y={focalLength_y}, center_x={center_x}, center_y={center_y}, skew={skew}, nrows={nrows}, ncols={ncols}, distCoeffs={distCoeffs})'.format(
      type=type(self).__name__,
      focalLength_x=self._focalLength_x,
      focalLength_y=self._focalLength_y,
      center_x=self._center_x,
      center_y=self._center_y,
      skew=self._skew,
      nrows=self._nrows,
      ncols=self._ncols,
      distCoeffs=msgbuffers.shorten_sequence(self._distCoeffs))

  def __repr__(self):
    return '{type}(focalLength_x={focalLength_x}, focalLength_y={focalLength_y}, center_x={center_x}, center_y={center_y}, skew={skew}, nrows={nrows}, ncols={ncols}, distCoeffs={distCoeffs})'.format(
      type=type(self).__name__,
      focalLength_x=repr(self._focalLength_x),
      focalLength_y=repr(self._focalLength_y),
      center_x=repr(self._center_x),
      center_y=repr(self._center_y),
      skew=repr(self._skew),
      nrows=repr(self._nrows),
      ncols=repr(self._ncols),
      distCoeffs=repr(self._distCoeffs))

Anki.Vector.CameraCalibration = CameraCalibration
del CameraCalibration


class IlluminationState(object):
  "Automatically-generated uint_8 enumeration."
  Unknown     = 0
  Illuminated = 1
  Darkened    = 2

Anki.Vector.IlluminationState = IlluminationState
del IlluminationState