dls-dodal 1.43.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

dodal/devices/oav/snapshots/snapshot.py

@@ -0,0 +1,21 @@
+from PIL import Image
+
+from dodal.devices.areadetector.plugins.MJPG import MJPG
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+class Snapshot(MJPG):
+    """A child of MJPG which, when triggered, saves the image to disk."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        super().__init__(prefix, name)
+
+    async def post_processing(self, image: Image.Image):
+        await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_image_processing.py

@@ -0,0 +1,74 @@
+from PIL import Image, ImageDraw
+
+from dodal.devices.oav.utils import Pixel
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
+    """
+    Draw a crosshair at the beam centre coordinates specified.
+    Args:
+        image: The image to draw the crosshair onto. This is mutated.
+        beam_x: The x-coordinate of the crosshair (pixels)
+        beam_y: The y-coordinate of the crosshair (pixels)
+    """
+    draw = ImageDraw.Draw(image)
+    OUTLINE_WIDTH = 1
+    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
+    draw.rectangle(
+        [
+            beam_x - OUTLINE_WIDTH,
+            beam_y - HALF_LEN - OUTLINE_WIDTH,
+            beam_x + OUTLINE_WIDTH,
+            beam_y + HALF_LEN + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.rectangle(
+        [
+            beam_x - HALF_LEN - OUTLINE_WIDTH,
+            beam_y - OUTLINE_WIDTH,
+            beam_x + HALF_LEN + OUTLINE_WIDTH,
+            beam_y + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.line(
+        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+    draw.line(
+        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+
+
+def compute_beam_centre_pixel_xy_for_mm_position(
+    sample_pos_mm: tuple[float, float],
+    beam_pos_at_origin_px: Pixel,
+    microns_per_pixel: tuple[float, float],
+) -> Pixel:
+    """
+    Compute the location of the beam centre in pixels on a reference image.
+    Args:
+        sample_pos_mm: x, y location of the sample in mm relative to when the reference image
+            was taken.
+        beam_pos_at_origin_px: x, y position of the beam centre in the reference image (pixels)
+        microns_per_pixel: x, y scaling factor relating the sample position to the position in the image.
+    Returns:
+        x, y location of the beam centre (pixels)
+
+    """
+
+    def centre(sample_pos, beam_pos, um_per_px) -> int:
+        return beam_pos + sample_pos * 1000 / um_per_px
+
+    return Pixel(
+        centre(sp, bp, mpp)
+        for sp, bp, mpp in zip(
+            sample_pos_mm, beam_pos_at_origin_px, microns_per_pixel, strict=True
+        )
+    )

dodal/plan_stubs/motor_utils.py

@@ -1,6 +1,6 @@
 import uuid
 from collections.abc import Generator
-from typing import Any, TypeVar, cast
+from typing import Any
 
 from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper, pchain
@@ -8,14 +8,14 @@ from bluesky.utils import Msg, MsgGenerator, make_decorator
 from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 
-from dodal.utils import MovableReadable
-
-MovableReadableDevice = TypeVar("MovableReadableDevice", bound=MovableReadable)
-
 
 class MoveTooLarge(Exception):
     def __init__(
-        self, axis: MovableReadable, maximum_move: float, position: float, *args: object
+        self,
+        axis: Motor,
+        maximum_move: float,
+        position: float,
+        *args: object,
     ) -> None:
         self.axis = axis
         self.maximum_move = maximum_move
@@ -24,10 +24,10 @@ class MoveTooLarge(Exception):
 
 
 def check_and_cache_values(
-    devices_and_positions: dict[MovableReadableDevice, float],
+    devices_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
-) -> Generator[Msg, Any, dict[MovableReadableDevice, float]]:
+) -> Generator[Msg, Any, dict[Motor, float]]:
     """Caches the positions of all Motors on specified device if they are within
     smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
     of the home_position
@@ -51,9 +51,7 @@ def home_and_reset_wrapper(
     wait_for_all: bool = True,
 ) -> MsgGenerator:
     home_positions = {
-        cast(MovableReadable, axis): 0.0
-        for _, axis in device.children()
-        if isinstance(axis, Motor)
+        axis: 0.0 for _, axis in device.children() if isinstance(axis, Motor)
     }
     return move_and_reset_wrapper(
         plan, home_positions, smallest_move, maximum_move, group, wait_for_all
@@ -62,7 +60,7 @@ def home_and_reset_wrapper(
 
 def move_and_reset_wrapper(
     plan: MsgGenerator,
-    device_and_positions: dict[MovableReadable, float],
+    device_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
     group: str | None = None,

dodal/utils.py

@@ -15,11 +15,9 @@ from types import ModuleType
 from typing import (
     Any,
     Generic,
-    Protocol,
     TypeAlias,
     TypeGuard,
     TypeVar,
-    runtime_checkable,
 )
 
 from bluesky.protocols import (
@@ -62,11 +60,6 @@ BLUESKY_PROTOCOLS = [
     Triggerable,
 ]
 
-
-@runtime_checkable
-class MovableReadable(Movable, Readable, Protocol): ...
-
-
 AnyDevice: TypeAlias = OphydV1Device | OphydV2Device
 V1DeviceFactory: TypeAlias = Callable[..., OphydV1Device]
 V2DeviceFactory: TypeAlias = Callable[..., OphydV2Device]

dodal/devices/i13_1/merlin_io.py

@@ -1,17 +0,0 @@
-from ophyd_async.core import StrictEnum
-from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_rw_rbv
-
-
-class MerlinImageMode(StrictEnum):
-    SINGLE = "Single"
-    MULTIPLE = "Multiple"
-    CONTINUOUS = "Continuous"
-    THRESHOLD = "Threshold"
-    BACKGROUND = "Background"
-
-
-class MerlinDriverIO(adcore.ADBaseIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(prefix, name)
-        self.image_mode = epics_signal_rw_rbv(MerlinImageMode, prefix + "ImageMode")

dodal/devices/oav/microns_for_zoom_levels.json

@@ -1,55 +0,0 @@
-{
-    "XRatio": 0.485,
-    "YRatio": 0.353,
-    "tolerance": 1.0,
-    "1.0": {
-        "position": 1.0,
-        "micronsPerXPixel": 2.309,
-        "micronsPerYPixel": 3.266
-    },
-    "2.0": {
-        "position": 2.0,
-        "micronsPerXPixel": 1.775,
-        "micronsPerYPixel": 2.493
-    },
-    "3.0": {
-        "position": 3.0,
-        "micronsPerXPixel": 1.334,
-        "micronsPerYPixel": 1.856
-    },
-    "4.0": {
-        "position": 4.0,
-        "micronsPerXPixel": 1.037,
-        "micronsPerYPixel": 1.425
-    },
-    "5.0": {
-        "position": 5.0,
-        "micronsPerXPixel": 0.798,
-        "micronsPerYPixel": 1.091
-    },
-    "6.0": {
-        "position": 6.0,
-        "micronsPerXPixel": 0.627,
-        "micronsPerYPixel": 0.870
-    },
-    "7.0": {
-        "position": 7.0,
-        "micronsPerXPixel": 0.487,
-        "micronsPerYPixel": 0.666
-    },
-    "8.0": {
-        "position": 8.0,
-        "micronsPerXPixel": 0.379,
-        "micronsPerYPixel": 0.516
-    },
-    "9.0": {
-        "position": 9.0,
-        "micronsPerXPixel": 0.289,
-        "micronsPerYPixel": 0.405
-    },
-    "10.0": {
-        "position": 10.0,
-        "micronsPerXPixel": 0.227,
-        "micronsPerYPixel": 0.314
-    }
-}

dodal/devices/oav/snapshots/snapshot_with_beam_centre.py

@@ -1,64 +0,0 @@
-from ophyd_async.core import Reference, SignalR
-from PIL import Image, ImageDraw
-
-from dodal.devices.areadetector.plugins.MJPG import MJPG
-
-CROSSHAIR_LENGTH_PX = 20
-CROSSHAIR_OUTLINE_COLOUR = "Black"
-CROSSHAIR_FILL_COLOUR = "White"
-
-
-def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
-    draw = ImageDraw.Draw(image)
-    OUTLINE_WIDTH = 1
-    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
-    draw.rectangle(
-        [
-            beam_x - OUTLINE_WIDTH,
-            beam_y - HALF_LEN - OUTLINE_WIDTH,
-            beam_x + OUTLINE_WIDTH,
-            beam_y + HALF_LEN + OUTLINE_WIDTH,
-        ],
-        fill=CROSSHAIR_OUTLINE_COLOUR,
-    )
-    draw.rectangle(
-        [
-            beam_x - HALF_LEN - OUTLINE_WIDTH,
-            beam_y - OUTLINE_WIDTH,
-            beam_x + HALF_LEN + OUTLINE_WIDTH,
-            beam_y + OUTLINE_WIDTH,
-        ],
-        fill=CROSSHAIR_OUTLINE_COLOUR,
-    )
-    draw.line(
-        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
-        fill=CROSSHAIR_FILL_COLOUR,
-    )
-    draw.line(
-        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
-        fill=CROSSHAIR_FILL_COLOUR,
-    )
-
-
-class SnapshotWithBeamCentre(MJPG):
-    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
-    centre in the image and saves the image to disk."""
-
-    def __init__(
-        self,
-        prefix: str,
-        beam_x_signal: SignalR,
-        beam_y_signal: SignalR,
-        name: str = "",
-    ) -> None:
-        with self.add_children_as_readables():
-            self._beam_centre_i_ref = Reference(beam_x_signal)
-            self._beam_centre_j_ref = Reference(beam_y_signal)
-        super().__init__(prefix, name)
-
-    async def post_processing(self, image: Image.Image):
-        beam_x = await self._beam_centre_i_ref().get_value()
-        beam_y = await self._beam_centre_j_ref().get_value()
-        draw_crosshair(image, beam_x, beam_y)
-
-        await self._save_image(image)