Update to work with R1.6 #195

Overwrites master tip to work with R1.6 robot. Note that this overwrites work previously done for R1.7.

This was done by:
* Working with a branch from 3/29/19
* Modifying that branch to work with R1.6
* Then branching from tip and putting this work ^^ on that branch
* Then merging this PR. Unfortunately the vector-proto submodule is probably in the wrong state.

Author: msintov

anki_vector/animation.py

@@ -190,7 +190,6 @@ async def load_animation_trigger_list(self):
         """
         return await self._load_animation_trigger_list()
 
-    # TODO: add return type hint
     @connection.on_connection_thread()
     async def play_animation_trigger(self, anim_trigger: str, loop_count: int = 1, use_lift_safe: bool = False, ignore_body_track: bool = False, ignore_head_track: bool = False, ignore_lift_track: bool = False):  # START
         """Starts an animation trigger playing on a robot.
@@ -228,7 +227,6 @@ async def play_animation_trigger(self, anim_trigger: str, loop_count: int = 1, u
                                                    ignore_lift_track=ignore_lift_track)
         return await self.grpc_interface.PlayAnimationTrigger(req)
 
-    # TODO: add return type hint
     @connection.on_connection_thread()
     async def play_animation(self, anim: str, loop_count: int = 1, ignore_body_track: bool = False, ignore_head_track: bool = False, ignore_lift_track: bool = False):
         """Starts an animation playing on a robot.

anki_vector/annotate.py

@@ -43,7 +43,7 @@
 from typing import Callable, Iterable, Tuple, Union
 
 try:
-    from PIL import Image, ImageDraw
+    from PIL import Image, ImageDraw, ImageFont
 except ImportError:
     sys.exit("Cannot import from PIL: Do `pip3 install --user Pillow` to install")
 except SyntaxError:
@@ -137,7 +137,7 @@ def clock(image, scale, annotator=None, world=None, **kw):
     """
 
     def __init__(self, text: str, position: int = AnnotationPosition.BOTTOM_RIGHT, align: str = "left", color: str = "white",
-                 font=None, line_spacing: int = 3, outline_color: str = None, full_outline: bool = True):
+                 font = None, line_spacing: int = 3, outline_color: str = None, full_outline: bool = True):
         self.text = text
         self.position = position
         self.align = align

anki_vector/audio.py

@@ -15,7 +15,6 @@
 """Support for accessing Vector's audio.
 
 Vector's speakers can be used for playing user-provided audio.
-TODO Ability to access the Vector's audio stream to come.
 
 The :class:`AudioComponent` class defined in this module is made available as
 :attr:`anki_vector.robot.Robot.audio` and can be used to play audio data on the robot.
@@ -56,7 +55,6 @@ class AudioComponent(util.Component):
     """Handles audio on Vector.
 
     The AudioComponent object plays audio data to Vector's speaker.
-    Ability to access the Vector's audio stream to come.
 
     The :class:`anki_vector.robot.Robot` or :class:`anki_vector.robot.AsyncRobot` instance
     owns this audio component.
@@ -69,8 +67,6 @@ class AudioComponent(util.Component):
             robot.audio.stream_wav_file('../examples/sounds/vector_alert.wav')
     """
 
-    # TODO restore audio feed code when ready
-
     def __init__(self, robot):
         super().__init__(robot)
         self._is_shutdown = False

anki_vector/behavior.py

@@ -26,7 +26,7 @@
 
 # __all__ should order by constants, event classes, other classes, functions.
 __all__ = ["EvtNewRawCameraImage", "EvtNewCameraImage",
-           "CameraComponent", "CameraConfig", "CameraImage"]
+           "CameraComponent", "CameraImage"]
 
 import asyncio
 from concurrent.futures import CancelledError
@@ -36,7 +36,7 @@
 
 from . import annotate, connection, util
 from .events import Events
-from .exceptions import VectorCameraFeedException, VectorCameraImageCaptureException
+from .exceptions import VectorCameraFeedException
 from .messaging import protocol
 
 try:
@@ -129,124 +129,12 @@ def annotate_image(self, scale: float = None, fit_size: tuple = None, resample_m
             (fast) or :attr:`~anki_vector.annotate.RESAMPLE_MODE_BILINEAR` (slower,
             but smoother).
         """
-        if self._raw_image.size != (640, 360):
-            raise VectorCameraImageCaptureException("Annotation is only supported for default resolution images.")
         return self._image_annotator.annotate_image(self._raw_image,
                                                     scale=scale,
                                                     fit_size=fit_size,
                                                     resample_mode=resample_mode)
 
 
-class CameraConfig:
-    """ The fixed properties for Vector's camera.
-
-    A full 3x3 calibration matrix for doing 3D reasoning based on the camera
-    images would look like:
-
-        +--------------+--------------+---------------+
-        |focal_length.x|      0       |    center.x   |
-        +--------------+--------------+---------------+
-        |       0      |focal_length.y|    center.y   |
-        +--------------+--------------+---------------+
-        |       0      |       0      |        1      |
-        +--------------+--------------+---------------+
-
-    .. testcode::
-
-        import anki_vector
-
-        with anki_vector.Robot() as robot:
-            min = robot.camera.config.min_gain
-            max = robot.camera.config.max_gain
-            print(f"Robot camera allowable exposure gain range is from {min} to {max}")
-    """
-
-    def __init__(self,
-                 focal_length_x: float,
-                 focal_length_y: float,
-                 center_x: float,
-                 center_y: float,
-                 fov_x: float,
-                 fov_y: float,
-                 min_exposure_time_ms: int,
-                 max_exposure_time_ms: int,
-                 min_gain: float,
-                 max_gain: float):
-        self._focal_length = util.Vector2(focal_length_x, focal_length_y)
-        self._center = util.Vector2(center_x, center_y)
-        self._fov_x = util.degrees(fov_x)
-        self._fov_y = util.degrees(fov_y)
-        self._min_exposure_ms = min_exposure_time_ms
-        self._max_exposure_ms = max_exposure_time_ms
-        self._min_gain = min_gain
-        self._max_gain = max_gain
-
-    @classmethod
-    def create_from_message(cls, msg: protocol.CameraConfigResponse):
-        """Create camera configuration based on Vector's camera configuration from the message sent from the Robot """
-        return cls(msg.focal_length_x,
-                   msg.focal_length_y,
-                   msg.center_x,
-                   msg.center_y,
-                   msg.fov_x,
-                   msg.fov_y,
-                   msg.min_camera_exposure_time_ms,
-                   msg.max_camera_exposure_time_ms,
-                   msg.min_camera_gain,
-                   msg.max_camera_gain)
-
-    @property
-    def min_gain(self) -> float:
-        """The minimum supported camera gain."""
-        return self._min_gain
-
-    @property
-    def max_gain(self) -> float:
-        """The maximum supported camera gain."""
-        return self._max_gain
-
-    @property
-    def min_exposure_time_ms(self) -> int:
-        """The minimum supported exposure time in milliseconds."""
-        return self._min_exposure_ms
-
-    @property
-    def max_exposure_time_ms(self) -> int:
-        """The maximum supported exposure time in milliseconds."""
-        return self._max_exposure_ms
-
-    @property
-    def focal_length(self):
-        """:class:`anki_vector.util.Vector2`: The focal length of the camera.
-
-        This is focal length combined with pixel skew (as the pixels aren't
-        perfectly square), so there are subtly different values for x and y.
-        It is in floating point pixel values e.g. <288.87, 288.36>.
-        """
-        return self._focal_length
-
-    @property
-    def center(self):
-        """:class:`anki_vector.util.Vector2`: The focal center of the camera.
-
-        This is the position of the optical center of projection within the
-        image. It will be close to the center of the image, but adjusted based
-        on the calibration of the lens. It is in floating point pixel values
-        e.g. <155.11, 111.40>.
-        """
-        return self._center
-
-    @property
-    def fov_x(self):
-        """:class:`anki_vector.util.Angle`: The x (horizontal) field of view."""
-        return self._fov_x
-
-    @property
-    def fov_y(self):
-        """:class:`anki_vector.util.Angle`: The y (vertical) field of view."""
-        return self._fov_y
-
-
 class CameraComponent(util.Component):
     """Represents Vector's camera.
 
@@ -279,55 +167,6 @@ def __init__(self, robot):
         self._latest_image_id: int = None
         self._camera_feed_task: asyncio.Task = None
         self._enabled = False
-        self._config = None  # type CameraConfig
-        self._gain = 0.0
-        self._exposure_ms = 0
-        self._auto_exposure_enabled = True
-
-    def set_config(self, message: protocol.CameraConfigRequest):
-        """Update Vector's camera configuration from the message sent from the Robot """
-        self._config = CameraConfig.create_from_message(message)
-
-    @connection.on_connection_thread(requires_control=False)
-    async def get_camera_config(self) -> protocol.CameraConfigResponse:
-        """ Get Vector's camera configuration
-
-        Retrieves the calibrated camera settings.  This is called during the Robot connection initialization, SDK
-        users should use the `config` property in most instances.
-
-        :return:
-        """
-        request = protocol.CameraConfigRequest()
-        return await self.conn.grpc_interface.GetCameraConfig(request)
-
-    @property
-    def config(self) -> CameraConfig:
-        """:class:`anki_vector.camera.CameraConfig`: The read-only config/calibration for the camera"""
-        return self._config
-
-    @property
-    def is_auto_exposure_enabled(self) -> bool:
-        """bool: True if auto exposure is currently enabled
-
-        If auto exposure is enabled the `gain` and `exposure_ms`
-        values will constantly be updated by Vector.
-        """
-        return self._auto_exposure_enabled
-
-    @property
-    def gain(self) -> float:
-        """float: The current camera gain setting."""
-        return self._gain
-
-    @property
-    def exposure_ms(self) -> int:
-        """int: The current camera exposure setting in milliseconds."""
-        return self._exposure_ms
-
-    def update_state(self, _robot, _event_type, msg):
-        self._gain = msg.gain
-        self._exposure_ms = msg.exposure_ms
-        self._auto_exposure_enabled = msg.auto_exposure_enabled
 
     @property
     @util.block_while_none()
@@ -491,7 +330,7 @@ async def _request_and_handle_images(self) -> None:
             self.logger.debug('Camera feed task was cancelled. This is expected during disconnection.')
 
     @connection.on_connection_thread()
-    async def capture_single_image(self, enable_high_resolution: bool = False) -> CameraImage:
+    async def capture_single_image(self) -> CameraImage:
         """Request to capture a single image from the robot's camera.
 
         This call requests the robot to capture an image and returns the
@@ -507,88 +346,17 @@ async def capture_single_image(self, enable_high_resolution: bool = False) -> Ca
             with anki_vector.Robot() as robot:
                 image = robot.camera.capture_single_image()
                 image.raw_image.show()
-
-        :param enable_high_resolution: Enable/disable request for high resolution images. The default resolution
-                                       is 640x360, while the high resolution is 1280x720.
         """
         if self._enabled:
-            self.logger.warning('Camera feed is enabled. Receiving image from the feed at default resolution.')
             return self._latest_image
-        if enable_high_resolution:
-            self.logger.warning('Capturing a high resolution (1280*720) image. Image events for this frame need to be scaled.')
-        req = protocol.CaptureSingleImageRequest(enable_high_resolution=enable_high_resolution)
+        req = protocol.CaptureSingleImageRequest()
         res = await self.grpc_interface.CaptureSingleImage(req)
         if res and res.data:
             image = _convert_to_pillow_image(res.data)
             return CameraImage(image, self._image_annotator, res.image_id)
 
         self.logger.error('Failed to capture a single image')
 
-    @connection.on_connection_thread()
-    async def enable_auto_exposure(self, enable_auto_exposure=True) -> protocol.SetCameraSettingsResponse:
-        """Enable auto exposure on Vector's Camera.
-
-        Enable auto exposure on Vector's camera to constantly update the exposure
-        time and gain values based on the recent images. This is the default mode
-        when any SDK program starts.
-
-        .. testcode::
-
-            import time
-            import anki_vector
-            with anki_vector.Robot() as robot:
-                robot.camera.enable_auto_exposure(False)
-                time.sleep(5)
-
-        :param enable_auto_exposure: whether the camera should automatically adjust exposure
-        """
-
-        set_camera_settings_request = protocol.SetCameraSettingsRequest(enable_auto_exposure=enable_auto_exposure)
-        result = await self.conn.grpc_interface.SetCameraSettings(set_camera_settings_request)
-        self._auto_exposure_enabled = enable_auto_exposure
-        return result
-
-    @connection.on_connection_thread()
-    async def set_manual_exposure(self, exposure_ms: int, gain: float) -> protocol.SetCameraSettingsResponse:
-        """Set manual exposure values for Vector's Camera.
-
-        This will disable auto exposure on Vector's camera and force the specified exposure
-        time and gain values.
-
-        .. testcode::
-
-            import time
-            import anki_vector
-            with anki_vector.Robot() as robot:
-                robot.camera.set_manual_exposure(1, 0.25)
-                time.sleep(5)
-
-        :param exposure_ms: The desired exposure time in milliseconds.
-                Must be within the robot's exposure range from :attr:`CameraConfig.min_exposure_time_ms` to
-                :attr:`CameraConfig.max_exposure_time_ms`
-        :param gain: The desired gain value.
-                Must be within the robot's gain range from :attr:`CameraConfig.min_gain` to
-                :attr:`CameraConfig.max_gain`
-        Raises:
-            :class:`ValueError` if supplied an out-of-range exposure or gain
-
-        """
-
-        if exposure_ms < self._config.min_exposure_time_ms \
-                or exposure_ms > self._config.max_exposure_time_ms \
-                or gain < self._config.min_gain \
-                or gain > self._config.max_gain:
-            raise ValueError("Exposure settings out of range")
-
-        set_camera_settings_request = protocol.SetCameraSettingsRequest(gain=gain,
-                                                                        exposure_ms=exposure_ms,
-                                                                        enable_auto_exposure=False)
-        result = await self.conn.grpc_interface.SetCameraSettings(set_camera_settings_request)
-        self._gain = gain
-        self._exposure_ms = exposure_ms
-        self._auto_exposure_enabled = False
-        return result
-
 
 class EvtNewRawCameraImage:  # pylint: disable=too-few-public-methods
     """Dispatched when a new raw image is received from the robot's camera.

anki_vector/camera.py

@@ -30,7 +30,6 @@
 import json
 import os
 from pathlib import Path
-import platform
 import re
 import socket
 import sys
@@ -67,10 +66,7 @@ class Api:
     def __init__(self):
         self._handler = ApiHandler(
             headers={
-                'User-Agent': 'Vector-sdk/{} {}/{}'.format(anki_vector.__version__,
-                                                           platform.python_implementation(),
-                                                           platform.python_version()),
-
+                'User-Agent': f'Vector-sdk/{anki_vector.__version__}',
                 'Anki-App-Key': 'aung2ieCho3aiph7Een3Ei'
             },
             url='https://accounts.api.anki.com/1/sessions'