StageAwareCamera: pad image with zeros when near image/stage limits (#231)

StageAwareCamera would error when stage position would cause it to
return pixels values outside the image border.  This commit handles
that case by returning an image padded with zeros.

Author: iandobbie

microscope/simulators/stage_aware_camera.py

@@ -103,16 +103,48 @@ def _fetch_data(self) -> typing.Optional[np.ndarray]:
         self._triggered -= 1
         _logger.info("Creating image")
 
-        # Use stage position to compute bounding box.
-        width = self._roi.width // self._binning.h
-        height = self._roi.height // self._binning.v
-        x = int((self._stage.position["x"] / self._pixel_size) - (width / 2))
-        y = int((self._stage.position["y"] / self._pixel_size) - (height / 2))
-
         # Use filter wheel position to select the image channel.
         channel = self._filterwheel.position
 
-        subsection = self._image[y : y + height, x : x + width, channel]
+        width = self._roi.width // self._binning.h
+        height = self._roi.height // self._binning.v
+
+        # Use stage position to compute bounding box.
+        xstart = int(
+            (self._stage.position["x"] / self._pixel_size) - (width / 2)
+        )
+        ystart = int(
+            (self._stage.position["y"] / self._pixel_size) - (height / 2)
+        )
+        xend = xstart + width
+        yend = ystart + height
+
+        # Need to check that the bounding box in entirely within the
+        # source image (see #231).
+        if (
+            xstart < 0
+            or ystart < 0
+            or xend > self._image.shape[1]
+            or yend > self._image.shape[0]
+        ):
+            # If part of image is out of bounds, pad with zeros, ...
+            subsection = np.zeros((height, width), dtype=self._image.dtype)
+            # work out the relevant parts of input image ...
+            img_x0 = max(0, xstart)
+            img_x1 = min(xend, self._image.shape[1])
+            img_y0 = max(0, ystart)
+            img_y1 = min(yend, self._image.shape[0])
+            # and work out where to place it in output image.
+            sub_x0 = max(-xstart, 0)
+            sub_y0 = max(-ystart, 0)
+            sub_x1 = sub_x0 + (img_x1 - img_x0)
+            sub_y1 = sub_y0 + (img_y1 - img_y0)
+
+            subsection[sub_y0:sub_y1, sub_x0:sub_x1] = self._image[
+                img_y0:img_y1, img_x0:img_x1, channel
+            ]
+        else:
+            subsection = self._image[ystart:yend, xstart:xend, channel]
 
         # Gaussian filter on abs Z position to simulate being out of
         # focus (Z position zero is in focus).

microscope/testsuite/test_devices.py

@@ -41,6 +41,7 @@
 
 import numpy
 
+import microscope
 import microscope.testsuite.devices as dummies
 import microscope.testsuite.mock_devices as mocks
 from microscope import simulators
@@ -441,6 +442,41 @@ def test_non_square_patterns_shape(self):
                 self.assertEqual(image.shape, (height, width))
 
 
+class TestStageAwareCamera(unittest.TestCase, CameraTests):
+    def setUp(self):
+        image = numpy.full((3000, 1500, 1), 42, dtype=numpy.uint8)
+        self.sensor_shape = (128, 128)
+        self.stage = simulators.SimulatedStage(
+            {
+                "x": microscope.AxisLimits(0, image.shape[1]),
+                "y": microscope.AxisLimits(0, image.shape[0]),
+                "z": microscope.AxisLimits(-50, 50),
+            }
+        )
+        self.stage.enable()
+        self.filterwheel = simulators.SimulatedFilterWheel(positions=1)
+        self.device = StageAwareCamera(
+            image, self.stage, self.filterwheel, sensor_shape=self.sensor_shape
+        )
+        self.buffer = Queue()
+        self.device.set_client(self.buffer)
+        self.device.enable()
+
+    def test_image_limits(self):
+        limits = self.stage.limits
+        for x, y in [
+            (limits["x"].lower, limits["y"].lower),
+            (limits["x"].lower, limits["y"].upper),
+            (limits["x"].upper, limits["y"].lower),
+            (limits["x"].upper, limits["y"].upper),
+        ]:
+            with self.subTest("limit x=%d and y=%d" % (x, y)):
+                self.stage.move_to({"x": x, "y": y})
+                self.device.trigger()
+                img = self.buffer.get()
+                self.assertEqual(img.shape, self.sensor_shape)
+
+
 class TestDummyController(unittest.TestCase, ControllerTests):
     def setUp(self):
         self.laser = simulators.SimulatedLightSource()