DiamondLightSource
diff --git a/‎src/dodal/beamlines/i04.py‎
Lines changed: 23 additions & 1 deletion b/‎src/dodal/beamlines/i04.py‎
Lines changed: 23 additions & 1 deletion
diff --git a/‎src/dodal/devices/i04/beam_centre.py‎
Lines changed: 84 additions & 0 deletions b/‎src/dodal/devices/i04/beam_centre.py‎
Lines changed: 84 additions & 0 deletions
diff --git a/‎src/dodal/devices/i04/max_pixel.py‎
Lines changed: 4 additions & 17 deletions b/‎src/dodal/devices/i04/max_pixel.py‎
Lines changed: 4 additions & 17 deletions
diff --git a/‎src/dodal/devices/oav/oav_detector.py‎
Lines changed: 66 additions & 1 deletion b/‎src/dodal/devices/oav/oav_detector.py‎
Lines changed: 66 additions & 1 deletion
diff --git a/‎src/dodal/devices/oav/utils.py‎
Lines changed: 17 additions & 0 deletions b/‎src/dodal/devices/oav/utils.py‎
Lines changed: 17 additions & 0 deletions
@@ -21,6 +21,7 @@
 from dodal.devices.fast_grid_scan import ZebraFastGridScanThreeD
 from dodal.devices.flux import Flux
 from dodal.devices.i03.dcm import DCM
+from dodal.devices.i04.beam_centre import CentreEllipseMethod
 from dodal.devices.i04.beamsize import Beamsize
 from dodal.devices.i04.constants import RedisConstants
 from dodal.devices.i04.max_pixel import MaxPixel
@@ -29,7 +30,10 @@
 from dodal.devices.ipin import IPin
 from dodal.devices.motors import XYZStage
 from dodal.devices.mx_phase1.beamstop import Beamstop
-from dodal.devices.oav.oav_detector import OAVBeamCentrePV
+from dodal.devices.oav.oav_detector import (
+    OAVBeamCentrePV,
+    ZoomControllerWithBeamCentres,
+)
 from dodal.devices.oav.oav_parameters import OAVConfig
 from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -271,6 +275,14 @@ def zebra() -> Zebra:
     )
 
 
+@device_factory()
+def zoom_controller() -> ZoomControllerWithBeamCentres:
+    """Get the i04 zoom controller, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i04, it will return the existing object.
+    """
+    return ZoomControllerWithBeamCentres(f"{PREFIX.beamline_prefix}-EA-OAV-01:FZOOM:")
+
+
 @device_factory(
     skip=BL == "s04",
 )
@@ -412,3 +424,13 @@ def beamsize() -> Beamsize:
         transfocator=transfocator(),
         aperture_scatterguard=aperture_scatterguard(),
     )
+
+
+@device_factory()
+def beam_centre() -> CentreEllipseMethod:
+    """Get the i04 centring device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i04, it will return the existing object.
+    """
+    return CentreEllipseMethod(
+        f"{PREFIX.beamline_prefix}-DI-OAV-01:",
+    )
@@ -0,0 +1,84 @@
+import cv2
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+from dodal.devices.oav.utils import convert_to_gray_and_blur
+from dodal.log import LOGGER
+
+# Constant was chosen from trial and error with test images
+ADDITIONAL_BINARY_THRESH = 20
+
+
+def convert_image_to_binary(image: np.ndarray):
+    """
+     Creates a binary image from OAV image array data.
+
+    Pixels of the input image are converted to one of two values (a high and a low value).
+    Otsu's method is used for automatic thresholding.
+    See https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html.
+    The threshold is increased by ADDITIONAL_BINARY_THRESH in order to get more of
+    the centre of the beam.
+    """
+    max_pixel_value = 255
+
+    blurred_image = convert_to_gray_and_blur(image)
+
+    threshold_value, _ = cv2.threshold(
+        blurred_image, 0, max_pixel_value, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+
+    # Adjusting because the inner beam is less noisy compared to the outer
+    threshold_value += ADDITIONAL_BINARY_THRESH
+
+    _, thresholded_image = cv2.threshold(
+        blurred_image, threshold_value, max_pixel_value, cv2.THRESH_BINARY
+    )
+
+    LOGGER.info(f"Image binarised with threshold of {threshold_value}")
+    return thresholded_image
+
+
+class CentreEllipseMethod(StandardReadable, Triggerable):
+    """
+    Upon triggering, fits an ellipse to a binary image from the area detector defined by
+    the prefix.
+
+    This is used, in conjunction with a scintillator, to determine the centre of the beam
+    on the image.
+    """
+
+    def __init__(self, prefix: str, name: str = ""):
+        self.oav_array_signal = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+
+        self.center_x_val, self._center_x_val_setter = soft_signal_r_and_setter(float)
+        self.center_y_val, self._center_y_val_setter = soft_signal_r_and_setter(float)
+        super().__init__(name)
+
+    def _fit_ellipse(self, binary_img: cv2.typing.MatLike) -> cv2.typing.RotatedRect:
+        contours, _ = cv2.findContours(
+            binary_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
+        )
+        if not contours:
+            raise ValueError("No contours found in image.")
+
+        largest_contour = max(contours, key=cv2.contourArea)
+        if len(largest_contour) < 5:
+            raise ValueError(
+                f"Not enough points to fit an ellipse. Found {largest_contour} points and need at least 5."
+            )
+
+        return cv2.fitEllipse(largest_contour)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        array_data = await self.oav_array_signal.get_value()
+        binary = convert_image_to_binary(array_data)
+        ellipse_fit = self._fit_ellipse(binary)
+        centre_x = ellipse_fit[0][0]
+        centre_y = ellipse_fit[0][1]
+        self._center_x_val_setter(centre_x)
+        self._center_y_val_setter(centre_y)
@@ -1,14 +1,11 @@
-import cv2
 import numpy as np
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
 from ophyd_async.epics.core import (
     epics_signal_r,
 )
 
-# kernal size describes how many of the neigbouring pixels are used for the blur,
-# higher kernal size means more of a blur effect
-KERNAL_SIZE = (7, 7)
+from dodal.devices.oav.utils import convert_to_gray_and_blur
 
 
 class MaxPixel(StandardReadable, Triggerable):
@@ -19,20 +16,10 @@ def __init__(self, prefix: str, name: str = "") -> None:
         self.max_pixel_val, self._max_val_setter = soft_signal_r_and_setter(float)
         super().__init__(name)
 
-    async def _convert_to_gray_and_blur(self):
-        """
-        Preprocess the image array data (convert to grayscale and apply a gaussian blur)
-        Image is converted to grayscale (using a weighted mean as green contributes more to brightness)
-        as we aren't interested in data relating to colour. A blur is then applied to mitigate
-        errors due to rogue hot pixels.
-        """
-        data = await self.array_data.get_value()
-        gray_arr = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
-        return cv2.GaussianBlur(gray_arr, KERNAL_SIZE, 0)
-
     @AsyncStatus.wrap
     async def trigger(self):
-        arr = await self._convert_to_gray_and_blur()
-        max_val = float(np.max(arr))  # np.int64
+        img_data = await self.array_data.get_value()
+        arr = convert_to_gray_and_blur(img_data)
+        max_val = float(np.max(arr))
         assert isinstance(max_val, float)
         self._max_val_setter(max_val)
@@ -1,13 +1,17 @@
+import asyncio
 from enum import IntEnum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DeviceMock,
+    DeviceVector,
     LazyMock,
     SignalR,
     SignalRW,
     StandardReadable,
+    default_mock_class,
     derived_signal_r,
     soft_signal_rw,
 )
@@ -22,6 +26,7 @@
 )
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
+from dodal.log import LOGGER
 
 
 class Coords(IntEnum):
@@ -56,26 +61,85 @@ async def set(self, value: str) -> None:
             await self.level.set(value, wait=True)
 
 
+class BeamCentreForZoom(StandardReadable):
+    """These PVs hold the beam centre on the OAV at each zoom level.
+
+    When the zoom level is changed the IOC will update the OAV overlay PVs to be at these positions."""
+
+    def __init__(
+        self, prefix: str, level_name_pv_suffix: str, centre_value_pv_suffix: str
+    ) -> None:
+        self.level_name = epics_signal_r(
+            str, f"{prefix}MP:SELECT.{level_name_pv_suffix}"
+        )
+        self.x_centre = epics_signal_rw(
+            float, f"{prefix}PBCX:VAL{centre_value_pv_suffix}"
+        )
+        self.y_centre = epics_signal_rw(
+            float, f"{prefix}PBCY:VAL{centre_value_pv_suffix}"
+        )
+        super().__init__()
+
+
+class InstantMovingZoom(DeviceMock["ZoomController"]):
+    """Mock behaviour that instantly moves the zoom."""
+
+    async def connect(self, device: "ZoomController") -> None:
+        """Mock signals to do an instant move on setpoint write."""
+        device.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 0.001  # type:ignore
+
+
+@default_mock_class(InstantMovingZoom)
 class ZoomController(BaseZoomController):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
         oav.zoom_controller.set("1.0x")
 
     Note that changing the zoom may change the AD wiring on the associated OAV, as such
-    you should wait on any zoom changs to finish before changing the OAV wiring.
+    you should wait on any zoom changes to finish before changing the OAV wiring.
     """
 
+    DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 2
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.percentage = epics_signal_rw(float, f"{prefix}ZOOMPOSCMD")
 
         # Level is the string description of the zoom level e.g. "1.0x" or "1.0"
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
+
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: str):
         await self.level.set(value, wait=True)
+        LOGGER.info(
+            "Waiting {self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S} seconds for zoom to be noticeable"
+        )
+        await asyncio.sleep(self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S)
+
+
+class ZoomControllerWithBeamCentres(ZoomController):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        level_to_centre_mapping = [
+            ("ZRST", "A"),
+            ("ONST", "B"),
+            ("TWST", "C"),
+            ("THST", "D"),
+            ("FRST", "E"),
+            ("FVST", "F"),
+            ("SXST", "G"),
+            ("SVST", "H"),
+        ]
+
+        self.beam_centres = DeviceVector(
+            {
+                i: BeamCentreForZoom(prefix, *level_to_centre_mapping[i])
+                for i in range(len(level_to_centre_mapping))
+            }
+        )
+
+        super().__init__(prefix, name)
 
 
 class OAV(StandardReadable):
@@ -118,6 +182,7 @@ def __init__(
             self.zoom_controller = zoom_controller
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
+
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(
                 f"{prefix}{mjpeg_prefix}:", name, mjpg_x_size_pv, mjpg_y_size_pv
 
@@ -2,6 +2,7 @@
 from enum import IntEnum
 
 import bluesky.plan_stubs as bps
+import cv2
 import numpy as np
 from bluesky.utils import Msg
 
@@ -119,3 +120,19 @@ def wait_for_tip_to_be_found(
         raise PinNotFoundError(f"No pin found after {timeout} seconds")
 
     return Pixel((int(found_tip[0]), int(found_tip[1])))
+
+
+def convert_to_gray_and_blur(data: cv2.typing.MatLike) -> cv2.typing.MatLike:
+    """
+    Preprocess the image array data (convert to grayscale and apply a gaussian blur)
+    Image is converted to grayscale (using a weighted mean as green contributes more to brightness)
+    as we aren't interested in data relating to colour. A blur is then applied to mitigate
+    errors due to rogue hot pixels.
+    """
+
+    # kernel size describes how many of the neighbouring pixels are used for the blur,
+    # higher kernal size means more of a blur effect
+    kernel_size = (7, 7)
+
+    gray_arr = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
+    return cv2.GaussianBlur(gray_arr, kernel_size, 0)