Merge pull request #172

Add missing overlay control properties

blueye/sdk/camera.py

@@ -217,6 +217,124 @@ def temperature_unit(self, unit: blueye.protocol.TemperatureUnit):
             self._overlay_parametres.temperature_unit = unit
             self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
 
+    @property
+    def cp_probe_enabled(self) -> bool:
+        """Get or set the state of the CP probe overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.cp_probe_enabled
+
+    @cp_probe_enabled.setter
+    def cp_probe_enabled(self, enable_cp_probe: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.cp_probe_enabled = enable_cp_probe
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def distance_enabled(self) -> bool:
+        """Get or set the state of the distance overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.distance_enabled
+
+    @distance_enabled.setter
+    def distance_enabled(self, enable_distance: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.distance_enabled = enable_distance
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def altitude_enabled(self) -> bool:
+        """Get or set the state of the altitude overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.altitude_enabled
+
+    @altitude_enabled.setter
+    def altitude_enabled(self, enable_altitude: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.altitude_enabled = enable_altitude
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def thickness_enabled(self) -> bool:
+        """Get or set the state of the thickness overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.thickness_enabled
+
+    @thickness_enabled.setter
+    def thickness_enabled(self, enable_thickness: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.thickness_enabled = enable_thickness
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def thickness_unit(self) -> blueye.protocol.ThicknessUnit:
+        """Get or set the thickness unit for the overlay
+
+        Needs to be set to an instance of the `blueye.protocol.ThicknessUnit` enum, if not a
+        RuntimeWarning is raised.
+        """
+        self._update_overlay_parameters()
+        return self._overlay_parametres.thickness_unit
+
+    @thickness_unit.setter
+    def thickness_unit(self, unit: blueye.protocol.ThicknessUnit):
+        if not isinstance(unit, blueye.protocol.ThicknessUnit):
+            warnings.warn("Invalid thickness unit, ignoring", RuntimeWarning)
+        else:
+            if self._overlay_parametres is None:
+                self._update_overlay_parameters()
+            self._overlay_parametres.thickness_unit = unit
+            self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def drone_location_enabled(self) -> bool:
+        """Get or set the state of the drone location overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.drone_location_enabled
+
+    @drone_location_enabled.setter
+    def drone_location_enabled(self, enable_drone_location: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.drone_location_enabled = enable_drone_location
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def shading(self) -> float:
+        """Get or set the pixel intensity to subtract from text background
+
+        0 is transparent, 1 is black.
+        Needs to be a float between 0.0 and 1.0, if not a RuntimeWarning is raised.
+        """
+        self._update_overlay_parameters()
+        return self._overlay_parametres.shading
+
+    @shading.setter
+    def shading(self, intensity: float):
+        if intensity < 0.0 or intensity > 1.0:
+            warnings.warn("Invalid shading intensity, ignoring", RuntimeWarning)
+        else:
+            if self._overlay_parametres is None:
+                self._update_overlay_parameters()
+            self._overlay_parametres.shading = intensity
+            self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
+    @property
+    def gamma_ray_measurement_enabled(self) -> bool:
+        """Get or set the state of the gamma-ray measurement overlay"""
+        self._update_overlay_parameters()
+        return self._overlay_parametres.medusa_enabled
+
+    @gamma_ray_measurement_enabled.setter
+    def gamma_ray_measurement_enabled(self, enable_gamma_ray_measurement: bool):
+        if self._overlay_parametres is None:
+            self._update_overlay_parameters()
+        self._overlay_parametres.medusa_enabled = enable_gamma_ray_measurement
+        self._parent_drone._req_rep_client.set_overlay_parameters(self._overlay_parametres)
+
     @property
     def timezone_offset(self) -> int:
         """Get or set the timezone offset for the overlay

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "blueye.sdk"
-version = "2.2.1"
+version = "2.3.0"
 description = "SDK for controlling a Blueye underwater drone"
 authors = ["Sindre Hansen <sindre.hansen@blueye.no>",
            "Johannes Schrimpf <johannes.schrimpf@blueye.no>",

tests/conftest.py

@@ -88,10 +88,12 @@ def mocked_drone(
         depth_enabled=False,
         heading_enabled=False,
         tilt_enabled=False,
+        thickness_enabled=False,
         date_enabled=False,
         distance_enabled=False,
         altitude_enabled=False,
         cp_probe_enabled=False,
+        medusa_enabled=False,
         drone_location_enabled=False,
         logo_type=bp.LogoType.LOGO_TYPE_NONE,
         depth_unit=bp.DepthUnit.DEPTH_UNIT_METERS,

tests/test_overlay_control.py

@@ -67,6 +67,82 @@ def test_get_temp_unit(self, mocked_drone: Drone):
             == bp.TemperatureUnit.TEMPERATURE_UNIT_CELSIUS
         )
 
+    def test_enable_cp_probe(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.cp_probe_enabled = True
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_get_cp_probe_state(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.cp_probe_enabled is False
+
+    def test_distance_enabled(self, mocked_drone):
+        mocked_drone.camera.overlay.distance_enabled = True
+        assert mocked_drone.camera.overlay.distance_enabled
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_get_distance_enabled(self, mocked_drone):
+        assert mocked_drone.camera.overlay.distance_enabled is False
+
+    def test_get_altitude_state(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.altitude_enabled is False
+
+    def test_enable_altitude(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.altitude_enabled = True
+        assert mocked_drone.camera.overlay.altitude_enabled
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_enable_thickness(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.thickness_enabled = True
+        assert mocked_drone.camera.overlay.thickness_enabled
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_get_thickness_state(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.thickness_enabled is False
+
+    def test_select_thickness_unit(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.thickness_unit = bp.ThicknessUnit.THICKNESS_UNIT_MILLIMETERS
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_select_thickness_unit_warns_and_ignores_for_wrong_type(self, mocked_drone: Drone):
+        with pytest.warns(RuntimeWarning):
+            mocked_drone.camera.overlay.thickness_unit = "wrong type"
+        assert mocked_drone._req_rep_client.set_overlay_parameters.called is False
+
+    def test_get_thickness_unit(self, mocked_drone: Drone):
+        assert (
+            mocked_drone.camera.overlay.thickness_unit
+            == bp.ThicknessUnit.THICKNESS_UNIT_MILLIMETERS
+        )
+
+    def test_get_drone_location_state(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.drone_location_enabled is False
+
+    def test_enable_drone_location(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.drone_location_enabled = True
+        assert mocked_drone.camera.overlay.drone_location_enabled is True
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_get_shading(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.shading == 0
+
+    def test_set_valid_shading(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.shading = 0
+        assert mocked_drone.camera.overlay.shading == 0
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
+    def test_set_invalid_shading_warns_and_ignores(self, mocked_drone: Drone):
+        with pytest.warns(RuntimeWarning):
+            mocked_drone.camera.overlay.shading = 1.5
+            mocked_drone.camera.overlay.shading = -0.5
+        assert mocked_drone._req_rep_client.set_overlay_parameters.called is False
+
+    def test_get_gamma_ray_measurement_state(self, mocked_drone: Drone):
+        assert mocked_drone.camera.overlay.gamma_ray_measurement_enabled is False
+
+    def test_enable_gamma_ray_measurement(self, mocked_drone: Drone):
+        mocked_drone.camera.overlay.gamma_ray_measurement_enabled = True
+        assert mocked_drone.camera.overlay.gamma_ray_measurement_enabled
+        mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()
+
     def test_set_timezone_offset(self, mocked_drone: Drone):
         mocked_drone.camera.overlay.timezone_offset = 120
         mocked_drone._req_rep_client.set_overlay_parameters.assert_called_once()