dls-dodal 1.33.0__py3-none-any.whl → 1.34.1__py3-none-any.whl

dodal/devices/oav/oav_detector.py

@@ -1,26 +1,35 @@
-# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
-from functools import partial
-
-from ophyd import ADComponent as ADC
-from ophyd import (
-    AreaDetector,
-    CamBase,
-    Component,
-    Device,
-    EpicsSignal,
-    HDF5Plugin,
-    OverlayPlugin,
-    ProcessPlugin,
-    ROIPlugin,
-    StatusBase,
-)
-
-from dodal.devices.areadetector.plugins.MJPG import SnapshotWithBeamCentre
-from dodal.devices.oav.grid_overlay import SnapshotWithGrid
-from dodal.devices.oav.oav_parameters import OAVConfigParams
-
-
-class ZoomController(Device):
+from enum import IntEnum
+
+from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, StandardReadable
+from ophyd_async.epics.signal import epics_signal_rw
+
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.devices.areadetector.plugins.CAM import Cam
+from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
+from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
+from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
+from dodal.log import LOGGER
+
+
+class ZoomLevelNotFoundError(Exception):
+    def __init__(self, errmsg):
+        LOGGER.error(errmsg)
+
+
+class Coords(IntEnum):
+    X = 0
+    Y = 1
+
+
+# Workaround to deal with the fact that beamlines may have slightly different string
+# descriptions of the zoom level"
+def _get_correct_zoom_string(zoom: str) -> str:
+    if zoom.endswith("x"):
+        zoom = zoom.strip("x")
+    return zoom
+
+
+class ZoomController(StandardReadable):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -30,63 +39,89 @@ class ZoomController(Device):
     you should wait on any zoom changs to finish before changing the OAV wiring.
     """
 
-    percentage = Component(EpicsSignal, "ZOOMPOSCMD")
-
-    # Level is the string description of the zoom level e.g. "1.0x"
-    level = Component(EpicsSignal, "MP:SELECT", string=True)
-
-    zrst = Component(EpicsSignal, "MP:SELECT.ZRST")
-    onst = Component(EpicsSignal, "MP:SELECT.ONST")
-    twst = Component(EpicsSignal, "MP:SELECT.TWST")
-    thst = Component(EpicsSignal, "MP:SELECT.THST")
-    frst = Component(EpicsSignal, "MP:SELECT.FRST")
-    fvst = Component(EpicsSignal, "MP:SELECT.FVST")
-    sxst = Component(EpicsSignal, "MP:SELECT.SXST")
-
-    @property
-    def allowed_zoom_levels(self):
-        return [
-            self.zrst.get(),
-            self.onst.get(),
-            self.twst.get(),
-            self.thst.get(),
-            self.frst.get(),
-            self.fvst.get(),
-            self.sxst.get(),
-        ]
-
-    def set(self, level_to_set: str) -> StatusBase:
-        return self.level.set(level_to_set)
-
-
-class OAV(AreaDetector):
-    cam = ADC(CamBase, "-DI-OAV-01:CAM:")
-    roi = ADC(ROIPlugin, "-DI-OAV-01:ROI:")
-    proc = ADC(ProcessPlugin, "-DI-OAV-01:PROC:")
-    over = ADC(OverlayPlugin, "-DI-OAV-01:OVER:")
-    tiff = ADC(OverlayPlugin, "-DI-OAV-01:TIFF:")
-    hdf5 = ADC(HDF5Plugin, "-DI-OAV-01:HDF5:")
-    grid_snapshot = Component(SnapshotWithGrid, "-DI-OAV-01:MJPG:")
-    snapshot = Component(SnapshotWithBeamCentre, "-DI-OAV-01:MJPG:")
-    zoom_controller = Component(ZoomController, "-EA-OAV-01:FZOOM:")
-
-    def __init__(self, *args, params: OAVConfigParams, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.parameters = params
-        self.grid_snapshot.oav_params = params
-        self.snapshot.oav_params = params
-        self.subscription_id = None
-        self._snapshot_trigger_subscription_id = None
-
-    def wait_for_connection(self, all_signals=False, timeout=2):
-        connected = super().wait_for_connection(all_signals, timeout)
-        x = self.grid_snapshot.x_size.get()
-        y = self.grid_snapshot.y_size.get()
-
-        cb = partial(self.parameters.update_on_zoom, xsize=x, ysize=y)
-
-        if self.subscription_id is not None:
-            self.zoom_controller.level.unsubscribe(self.subscription_id)
-        self.subscription_id = self.zoom_controller.level.subscribe(cb)
-
-        return connected
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(name=name)
+        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")
+
+    async def _get_allowed_zoom_levels(self) -> list:
+        zoom_levels = await self.level.describe()
+        return zoom_levels["level"]["choices"]  # type: ignore
+
+    @AsyncStatus.wrap
+    async def set(self, level_to_set: str):
+        allowed_zoom_levels = await self._get_allowed_zoom_levels()
+        if level_to_set not in allowed_zoom_levels:
+            raise ZoomLevelNotFoundError(
+                f"{level_to_set} not found, expected one of {allowed_zoom_levels}"
+            )
+        await self.level.set(level_to_set, wait=True)
+
+
+class OAV(StandardReadable):
+    def __init__(self, prefix: str, config: OAVConfig, name: str = ""):
+        self.oav_config = config
+        self._prefix = prefix
+        self._name = name
+        _bl_prefix = prefix.split("-")[0]
+        self.zoom_controller = ZoomController(f"{_bl_prefix}-EA-OAV-01:FZOOM:", name)
+
+        self.cam = Cam(f"{prefix}CAM:", name=name)
+
+        with self.add_children_as_readables():
+            self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
+            self.microns_per_pixel_x = create_hardware_backed_soft_signal(
+                float,
+                lambda: self._get_microns_per_pixel(Coords.X),
+            )
+            self.microns_per_pixel_y = create_hardware_backed_soft_signal(
+                float,
+                lambda: self._get_microns_per_pixel(Coords.Y),
+            )
+            self.beam_centre_i = create_hardware_backed_soft_signal(
+                int, lambda: self._get_beam_position(Coords.X)
+            )
+            self.beam_centre_j = create_hardware_backed_soft_signal(
+                int, lambda: self._get_beam_position(Coords.Y)
+            )
+            self.snapshot = SnapshotWithBeamCentre(
+                f"{self._prefix}MJPG:",
+                self.beam_centre_i,
+                self.beam_centre_j,
+                self._name,
+            )
+
+        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+
+        super().__init__(name)
+
+    async def _read_current_zoom(self) -> str:
+        _zoom = await self.zoom_controller.level.get_value()
+        return _get_correct_zoom_string(_zoom)
+
+    async def _get_microns_per_pixel(self, coord: int) -> float:
+        """Extracts the microns per x pixel and y pixel for a given zoom level."""
+        _zoom = await self._read_current_zoom()
+        value = self.parameters[_zoom].microns_per_pixel[coord]
+        size = await self.sizes[coord].get_value()
+        return value * DEFAULT_OAV_WINDOW[coord] / size
+
+    async def _get_beam_position(self, coord: int) -> int:
+        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
+        zoom level. """
+        _zoom = await self._read_current_zoom()
+        value = self.parameters[_zoom].crosshair[coord]
+        size = await self.sizes[coord].get_value()
+        return int(value * size / DEFAULT_OAV_WINDOW[coord])
+
+    async def connect(
+        self,
+        mock: bool = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ):
+        self.parameters = self.oav_config.get_parameters()
+
+        return await super().connect(mock, timeout, force_reconnect)

dodal/devices/oav/oav_parameters.py

@@ -1,15 +1,10 @@
 import json
 import xml.etree.ElementTree as et
 from collections import ChainMap
+from dataclasses import dataclass
 from typing import Any
 from xml.etree.ElementTree import Element
 
-from dodal.devices.oav.oav_errors import (
-    OAVError_BeamPositionNotFound,
-    OAVError_ZoomLevelNotFound,
-)
-from dodal.log import LOGGER
-
 # GDA currently assumes this aspect ratio for the OAV window size.
 # For some beamline this doesn't affect anything as the actual OAV aspect ratio
 # matches. Others need to take it into account to rescale the values stored in
@@ -109,106 +104,57 @@ class OAVParameters:
         return self.max_tip_distance / micronsPerPixel
 
 
-class OAVConfigParams:
-    """
-    The OAV parameters which may update depending on settings such as the zoom level.
-    """
+@dataclass
+class ZoomParams:
+    microns_per_pixel: tuple[float, float]
+    crosshair: tuple[int, int]
 
-    def __init__(
-        self,
-        zoom_params_file,
-        display_config,
-    ):
-        self.zoom_params_file: str = zoom_params_file
-        self.display_config: str = display_config
-
-    def update_on_zoom(self, value, xsize, ysize, *args, **kwargs):
-        xsize, ysize = int(xsize), int(ysize)
-        if isinstance(value, str) and value.endswith("x"):
-            value = value.strip("x")
-        zoom = float(value)
-        self.load_microns_per_pixel(zoom, xsize, ysize)
-        self.beam_centre_i, self.beam_centre_j = self.get_beam_position_from_zoom(
-            zoom, xsize, ysize
-        )
-
-    def load_microns_per_pixel(self, zoom: float, xsize: int, ysize: int) -> None:
-        """
-        Loads the microns per x pixel and y pixel for a given zoom level. These are
-        currently generated by GDA, though hyperion could generate them in future.
-        """
-        tree = et.parse(self.zoom_params_file)
-        self.micronsPerXPixel = self.micronsPerYPixel = None
-        root = tree.getroot()
-        levels = root.findall(".//zoomLevel")
-        for node in levels:
-            if _get_element_as_float(node, "level") == zoom:
-                self.micronsPerXPixel = (
-                    _get_element_as_float(node, "micronsPerXPixel")
-                    * DEFAULT_OAV_WINDOW[0]
-                    / xsize
-                )
-                self.micronsPerYPixel = (
-                    _get_element_as_float(node, "micronsPerYPixel")
-                    * DEFAULT_OAV_WINDOW[1]
-                    / ysize
-                )
-        if self.micronsPerXPixel is None or self.micronsPerYPixel is None:
-            raise OAVError_ZoomLevelNotFound(
-                f"""
-                Could not find the micronsPer[X,Y]Pixel parameters in
-                {self.zoom_params_file} for zoom level {zoom}.
-                """
-            )
 
-    def get_beam_position_from_zoom(
-        self, zoom: float, xsize: int, ysize: int
-    ) -> tuple[int, int]:
-        """
-        Extracts the beam location in pixels `xCentre` `yCentre`, for a requested zoom \
-        level. The beam location is manually inputted by the beamline operator on GDA \
-        by clicking where on screen a scintillator lights up, and stored in the \
-        display.configuration file.
-        """
-        crosshair_x_line = None
-        crosshair_y_line = None
-        with open(self.display_config) as f:
-            file_lines = f.readlines()
-            for i in range(len(file_lines)):
-                if file_lines[i].startswith("zoomLevel = " + str(zoom)):
-                    crosshair_x_line = file_lines[i + 1]
-                    crosshair_y_line = file_lines[i + 2]
-                    break
-
-        if crosshair_x_line is None or crosshair_y_line is None:
-            raise OAVError_BeamPositionNotFound(
-                f"Could not extract beam position at zoom level {zoom}"
-            )
+class OAVConfig:
+    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
+    with information about microns per pixels and crosshairs.
+    """
 
-        beam_centre_i = (
-            int(crosshair_x_line.split(" = ")[1]) * xsize / DEFAULT_OAV_WINDOW[0]
-        )
-        beam_centre_j = (
-            int(crosshair_y_line.split(" = ")[1]) * ysize / DEFAULT_OAV_WINDOW[1]
-        )
-        LOGGER.info(f"Beam centre: {beam_centre_i, beam_centre_j}")
-        return int(beam_centre_i), int(beam_centre_j)
+    def __init__(self, zoom_params_file: str, display_config_file: str):
+        self.zoom_params = self._get_zoom_params(zoom_params_file)
+        self.display_config = self._get_display_config(display_config_file)
 
-    def calculate_beam_distance(
-        self, horizontal_pixels: int, vertical_pixels: int
-    ) -> tuple[int, int]:
-        """
-        Calculates the distance between the beam centre and the given (horizontal, vertical).
-
-        Args:
-            horizontal_pixels (int): The x (camera coordinates) value in pixels.
-            vertical_pixels (int): The y (camera coordinates) value in pixels.
-        Returns:
-            The distance between the beam centre and the (horizontal, vertical) point in pixels as a tuple
-            (horizontal_distance, vertical_distance).
-        """
+    def _get_display_config(self, display_config_file: str):
+        with open(display_config_file) as f:
+            file_lines = f.readlines()
+        return file_lines
 
-        return (
-            self.beam_centre_i - horizontal_pixels,
-            self.beam_centre_j - vertical_pixels,
-        )
+    def _get_zoom_params(self, zoom_params_file: str):
+        tree = et.parse(zoom_params_file)
+        root = tree.getroot()
+        return root.findall(".//zoomLevel")
+
+    def _read_zoom_params(self) -> dict:
+        um_per_pix = {}
+        for node in self.zoom_params:
+            zoom = str(_get_element_as_float(node, "level"))
+            um_pix_x = _get_element_as_float(node, "micronsPerXPixel")
+            um_pix_y = _get_element_as_float(node, "micronsPerYPixel")
+            um_per_pix[zoom] = (um_pix_x, um_pix_y)
+        return um_per_pix
+
+    def _read_display_config(self) -> dict:
+        crosshairs = {}
+        for i in range(len(self.display_config)):
+            if self.display_config[i].startswith("zoomLevel"):
+                zoom = self.display_config[i].split(" = ")[1].strip()
+                x = int(self.display_config[i + 1].split(" = ")[1])
+                y = int(self.display_config[i + 2].split(" = ")[1])
+                crosshairs[zoom] = (x, y)
+        return crosshairs
+
+    def get_parameters(self) -> dict[str, ZoomParams]:
+        config = {}
+        um_xy = self._read_zoom_params()
+        bc_xy = self._read_display_config()
+        for zoom_key in list(bc_xy.keys()):
+            config[zoom_key] = ZoomParams(
+                microns_per_pixel=um_xy[zoom_key],
+                crosshair=bc_xy[zoom_key],
+            )
+        return config

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -1,21 +1,20 @@
 import asyncio
-import io
-import pickle
-import uuid
 from collections.abc import Awaitable, Callable
 from datetime import timedelta
+from enum import Enum
+from uuid import uuid4
 
-import numpy as np
 from aiohttp import ClientResponse, ClientSession
 from bluesky.protocols import Flyable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
+    DeviceVector,
     StandardReadable,
+    observe_value,
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
 from ophyd_async.epics.signal import epics_signal_r
-from PIL import Image
 from redis.asyncio import StrictRedis
 
 from dodal.log import LOGGER
@@ -30,6 +29,21 @@ async def get_next_jpeg(response: ClientResponse) -> bytes:
             return line + await response.content.readuntil(JPEG_STOP_BYTE)
 
 
+class Source(Enum):
+    FULL_SCREEN = 0
+    ROI = 1
+
+
+class OAVSource(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        oav_name: str,
+    ):
+        self.url = epics_signal_r(str, f"{prefix}MJPG_URL_RBV")
+        self.oav_name = oav_name
+
+
 class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     """Forwards OAV image data to redis. To use call:
 
@@ -41,6 +55,9 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
 
     DATA_EXPIRY_DAYS = 7
 
+    # This timeout is the maximum time that the forwarder can be streaming for
+    TIMEOUT = 30
+
     def __init__(
         self,
         prefix: str,
@@ -59,59 +76,80 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
             redis_db: int           which redis database to connect to, defaults to 0
             name: str               the name of this device
         """
-        self.stream_url = epics_signal_r(str, f"{prefix}MJPG:MJPG_URL_RBV")
+        self.counter = epics_signal_r(int, f"{prefix}CAM:ArrayCounter_RBV")
 
-        with self.add_children_as_readables():
-            self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
+        self._sources = DeviceVector(
+            {
+                Source.ROI.value: OAVSource(f"{prefix}MJPG:", "roi"),
+                Source.FULL_SCREEN.value: OAVSource(f"{prefix}XTAL:", "fullscreen"),
+            }
+        )
+        self.selected_source = soft_signal_rw(Source)
 
         self.forwarding_task = None
         self.redis_client = StrictRedis(
             host=redis_host, password=redis_password, db=redis_db
         )
 
-        self._stop_flag = False
+        self._stop_flag = asyncio.Event()
 
         self.sample_id = soft_signal_rw(int, initial_value=0)
 
-        # The uuid that images are being saved under, this should be monitored for
-        # callbacks to correlate the data
-        self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
+        with self.add_children_as_readables():
+            # The uuid that images are being saved under, this should be monitored for
+            # callbacks to correlate the data
+            self.uuid, self.uuid_setter = soft_signal_r_and_setter(str)
 
         super().__init__(name=name)
 
-    async def _get_frame_and_put_to_redis(self, response: ClientResponse):
-        """Converts the data that comes in as a jpeg byte stream into a numpy array of
-        RGB values, pickles this array then writes it to redis.
-        """
+    async def _get_frame_and_put_to_redis(
+        self, redis_uuid: str, response: ClientResponse
+    ):
+        """Stores the raw bytes of the jpeg image in redis. Murko ultimately wants a
+        pickled numpy array of pixel values but raw byes are more space efficient. There
+        may be better ways of doing this, see https://github.com/DiamondLightSource/mx-bluesky/issues/592"""
         jpeg_bytes = await get_next_jpeg(response)
-        self.uuid_setter(image_uuid := str(uuid.uuid4()))
-        img = Image.open(io.BytesIO(jpeg_bytes))
-        image_data = pickle.dumps(np.asarray(img))
-        sample_id = str(await self.sample_id.get_value())
-        await self.redis_client.hset(sample_id, image_uuid, image_data)  # type: ignore
-        await self.redis_client.expire(sample_id, timedelta(days=self.DATA_EXPIRY_DAYS))
-        LOGGER.debug(f"Sent frame to redis key {sample_id} with uuid {image_uuid}")
+        self.uuid_setter(redis_uuid)
+        sample_id = await self.sample_id.get_value()
+        redis_key = f"murko:{sample_id}:raw"
+        await self.redis_client.hset(redis_key, redis_uuid, jpeg_bytes)  # type: ignore
+        await self.redis_client.expire(redis_key, timedelta(days=self.DATA_EXPIRY_DAYS))
 
     async def _open_connection_and_do_function(
-        self, function_to_do: Callable[[ClientResponse, str | None], Awaitable]
+        self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]
     ):
-        stream_url = await self.stream_url.get_value()
+        source_name = await self.selected_source.get_value()
+        LOGGER.info(
+            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_name}"
+        )
+        source = self._sources[source_name.value]
+        stream_url = await source.url.get_value()
         async with ClientSession() as session:
             async with session.get(stream_url) as response:
-                await function_to_do(response, stream_url)
+                await function_to_do(response, source)
+
+    async def _stream_to_redis(self, response: ClientResponse, source: OAVSource):
+        """Uses the update of the frame counter as a trigger to pull an image off the OAV
+        and into redis.
 
-    async def _stream_to_redis(self, response, _):
-        while not self._stop_flag:
-            await self._get_frame_and_put_to_redis(response)
-            await asyncio.sleep(0.01)
+        The frame counter is continually increasing on the timescales we store data and
+        so can be used as a uuid. If the OAV is updating too quickly we may drop frames
+        but in this case a best effort on getting as many frames as possible is sufficient.
+        """
+        done_status = AsyncStatus(
+            asyncio.wait_for(self._stop_flag.wait(), timeout=self.TIMEOUT)
+        )
+        async for frame_count in observe_value(self.counter, done_status=done_status):
+            redis_uuid = f"{source.oav_name}-{frame_count}-{uuid4()}"
+            await self._get_frame_and_put_to_redis(redis_uuid, response)
 
-    async def _confirm_mjpg_stream(self, response, stream_url):
+    async def _confirm_mjpg_stream(self, response: ClientResponse, source: OAVSource):
         if response.content_type != "multipart/x-mixed-replace":
-            raise ValueError(f"{stream_url} is not an MJPG stream")
+            raise ValueError(f"{await source.url.get_value()} is not an MJPG stream")
 
     @AsyncStatus.wrap
     async def kickoff(self):
-        self._stop_flag = False
+        self._stop_flag.clear()
         await self._open_connection_and_do_function(self._confirm_mjpg_stream)
         self.forwarding_task = asyncio.create_task(
             self._open_connection_and_do_function(self._stream_to_redis)
@@ -125,5 +163,8 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     @AsyncStatus.wrap
     async def stop(self, success=True):
         if self.forwarding_task:
-            self._stop_flag = True
+            LOGGER.info(
+                f"Stopping forwarding for {await self.selected_source.get_value()}"
+            )
+            self._stop_flag.set()
             await self.forwarding_task

dodal/devices/oav/{grid_overlay.py → snapshots/grid_overlay.py}

@@ -1,14 +1,8 @@
-# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
 from enum import Enum
 from functools import partial
-from os.path import join as path_join
 
-from ophyd import Component, Signal
 from PIL import Image, ImageDraw
 
-from dodal.devices.areadetector.plugins.MJPG import MJPG
-from dodal.log import LOGGER
-
 
 class Orientation(Enum):
     horizontal = 0
@@ -122,40 +116,3 @@ def add_grid_overlay_to_image(
         spacing=box_width,
         num_lines=num_boxes_y - 1,
     )
-
-
-class SnapshotWithGrid(MJPG):
-    top_left_x = Component(Signal)
-    top_left_y = Component(Signal)
-    box_width = Component(Signal)
-    num_boxes_x = Component(Signal)
-    num_boxes_y = Component(Signal)
-
-    last_path_outer = Component(Signal)
-    last_path_full_overlay = Component(Signal)
-
-    def post_processing(self, image: Image.Image):
-        # Save an unmodified image with no suffix
-        self._save_image(image)
-
-        top_left_x = self.top_left_x.get()
-        top_left_y = self.top_left_y.get()
-        box_width = self.box_width.get()
-        num_boxes_x = self.num_boxes_x.get()
-        num_boxes_y = self.num_boxes_y.get()
-        assert isinstance(filename_str := self.filename.get(), str)
-        assert isinstance(directory_str := self.directory.get(), str)
-        add_grid_border_overlay_to_image(
-            image, top_left_x, top_left_y, box_width, num_boxes_x, num_boxes_y
-        )
-        path = path_join(directory_str, f"{filename_str}_outer_overlay.png")
-        self.last_path_outer.put(path)
-        LOGGER.info(f"Saving grid outer edge at {path}")
-        image.save(path)
-        add_grid_overlay_to_image(
-            image, top_left_x, top_left_y, box_width, num_boxes_x, num_boxes_y
-        )
-        path = path_join(directory_str, f"{filename_str}_grid_overlay.png")
-        self.last_path_full_overlay.put(path)
-        LOGGER.info(f"Saving full grid overlay at {path}")
-        image.save(path)