Merge pull request #38 from DiamondLightSource/I04_1-156_messages

I04 1 156 messages

Author: IsabellaRey

dls_barcode/camera/camera_scanner.py

@@ -1,29 +1,14 @@
 from __future__ import division
 
 import multiprocessing
-import time
 import queue
 
-from dls_util.image import Image, Color
-from dls_util import Beeper
-from dls_barcode.scan import GeometryScanner, SlotScanner, OpenScanner
-from dls_barcode.datamatrix import DataMatrix
-from .overlay import PlateOverlay, TextOverlay
 from .capture_worker import CaptureWorker
+from .scanner_worker import ScannerWorker
 from .camera_position import CameraPosition
 from .stream_action import StreamAction
 from .capture_command import CaptureCommand
 
-Q_LIMIT = 1
-SCANNED_TAG = "Scan Complete"
-NO_PUCK_TIME = 2
-
-EXIT_KEY = 'q'
-
-# Maximum frame rate to sample at (rate will be further limited by speed at which frames can be processed)
-MAX_SAMPLE_RATE = 10.0
-INTERVAL = 1.0 / MAX_SAMPLE_RATE
-
 
 class CameraScanner:
     """ Manages the continuous scanning mode which takes a live feed from an attached camera and
@@ -33,7 +18,7 @@ class CameraScanner:
     Two separate processes are spawned, one to handle capturing and displaying images from the cameras,
     and the other to handle processing (scanning) of those images.
     """
-    def __init__(self, result_queue, view_queue, config):
+    def __init__(self, result_queue, view_queue, message_queue, config):
         """ The task queue is used to store a queue of captured frames to be processed; the overlay
         queue stores Overlay objects which are drawn on to the image displayed to the user to highlight
         certain features; and the result queue is used to pass on the results of successful scans to
@@ -46,6 +31,7 @@ def __init__(self, result_queue, view_queue, config):
         self._scanner_kill_q = multiprocessing.Queue()
         self._result_q = result_queue
         self._view_q = view_queue
+        self._message_q = message_queue
 
         self._config = config
         self._camera_configs = {CameraPosition.SIDE: self._config.get_side_camera_config(),
@@ -55,7 +41,7 @@ def __init__(self, result_queue, view_queue, config):
                         self._camera_configs)
 
         # The capture process is always running: we initialise the cameras only once because it's time consuming
-        self._capture_process = multiprocessing.Process(target=_capture_worker, args=capture_args)
+        self._capture_process = multiprocessing.Process(target=CameraScanner._capture_worker, args=capture_args)
         self._capture_process.start()
 
         self._scanner_process = None
@@ -64,8 +50,8 @@ def start_scan(self, cam_position):
         """ Spawn the processes that will continuously capture and process images from the camera.
         """
         print("\nMAIN: start triggered")
-        scanner_args = (self._task_q, self._overlay_q, self._result_q, self._scanner_kill_q, self._config, cam_position)
-        self._scanner_process = multiprocessing.Process(target=_scanner_worker, args=scanner_args)
+        scanner_args = (self._task_q, self._overlay_q, self._result_q, self._message_q, self._scanner_kill_q, self._config, cam_position)
+        self._scanner_process = multiprocessing.Process(target=CameraScanner._scanner_worker, args=scanner_args)
 
         self._capture_command_q.put(CaptureCommand(StreamAction.START, cam_position))
         self._scanner_process.start()
@@ -95,7 +81,7 @@ def _terminate_scanner_process(self):
         if self._scanner_process is not None:
             self._scanner_kill_q.put(None)
             print("MAIN: forcing scanner cleanup")
-            self._process_cleanup(self._scanner_process, [self._result_q, self._overlay_q])
+            self._process_cleanup(self._scanner_process, [self._result_q, self._overlay_q, self._message_q])
             self._scanner_process.join()
             self._flush_queue(self._scanner_kill_q)
             self._scanner_process = None
@@ -131,90 +117,14 @@ def _process_cleanup(self, process, queues):
 
         print("MAIN: sub-process terminated!")
 
+    @staticmethod
+    def _capture_worker(task_queue, view_queue, overlay_queue, command_queue, kill_queue, camera_configs):
+        """ Function used as the main loop of a worker process.
+        """
+        CaptureWorker(camera_configs).run(task_queue, view_queue, overlay_queue, command_queue, kill_queue)
 
-def _capture_worker(task_queue, view_queue, overlay_queue, command_queue, kill_queue, camera_configs):
-    """ Function used as the main loop of a worker process.
-    """
-    worker = CaptureWorker(camera_configs)
-    worker.run(task_queue, view_queue, overlay_queue, command_queue, kill_queue)
-
-
-def _scanner_worker(task_queue, overlay_queue, result_queue, kill_queue, config, cam_position):
-    """ Function used as the main loop of a worker process. Scan images for barcodes,
-    combining partial scans until a full puck is reached.
-
-    Keep the record of the last scan which was at least partially successful (aligned geometry
-    and some barcodes scanned). For each new frame, we can attempt to merge the results with
-    this previous plates so that we don't have to re-read any of the previously captured barcodes
-    (because this is a relatively expensive operation).
-    """
-    print("SCANNER start")
-    last_plate_time = time.time()
-
-    SlotScanner.DEBUG = config.slot_images.value()
-    SlotScanner.DEBUG_DIR = config.slot_image_directory.value()
-
-    if cam_position == CameraPosition.SIDE:
-        plate_type = "None"
-        barcode_sizes = DataMatrix.DEFAULT_SIDE_SIZES
-    else:
-        plate_type = config.plate_type.value()
-        barcode_sizes = [config.top_barcode_size.value()]
-
-    if plate_type == "None":
-        scanner = OpenScanner(barcode_sizes)
-    else:
-        scanner = GeometryScanner(plate_type, barcode_sizes)
-
-    display = True
-    while kill_queue.empty():
-        if display:
-            print("--- scanner inside loop")
-            display = False
-        if task_queue.empty():
-            continue
-
-        frame = task_queue.get(True)
-
-        # Make grayscale version of image
-        image = Image(frame)
-        gray_image = image.to_grayscale()
-
-        # If we have an existing partial plate, merge the new plate with it and only try to read the
-        # barcodes which haven't already been read. This significantly increases efficiency because
-        # barcode read is expensive.
-        scan_result = scanner.scan_next_frame(gray_image)
-
-        if config.console_frame.value():
-            scan_result.print_summary()
-
-        if scan_result.success():
-            # Record the time so we can see how long its been since we last saw a plate
-            last_plate_time = time.time()
-
-            plate = scan_result.plate()
-
-            if scan_result.already_scanned():
-                overlay_queue.put(TextOverlay(SCANNED_TAG, Color.Green()))
-            elif scan_result.any_valid_barcodes():
-                overlay_queue.put(PlateOverlay(plate, config))
-                _plate_beep(plate, config.scan_beep.value())
-
-            if scan_result.any_new_barcodes():
-                result_queue.put((plate, image))
-        else:
-            time_since_plate = time.time() - last_plate_time
-            if time_since_plate > NO_PUCK_TIME:
-                overlay_queue.put(TextOverlay(scan_result.error(), Color.Red()))
-
-    print("SCANNER stop & kill")
-
-
-def _plate_beep(plate, do_beep):
-    if not do_beep:
-        return
-
-    empty_fraction = (plate.num_slots - plate.num_valid_barcodes()) / plate.num_slots
-    frequency = int(10000 * empty_fraction + 37)
-    duration = 200
-    Beeper.beep(frequency, duration)
+    @staticmethod
+    def _scanner_worker(task_queue, overlay_queue, result_queue, message_queue, kill_queue, config, cam_position):
+        """ Function used as the main loop of a worker process.
+        """
+        ScannerWorker().run(task_queue, overlay_queue, result_queue, message_queue, kill_queue, config, cam_position)

dls_barcode/camera/capture_worker.py

@@ -1,7 +1,7 @@
 import time
 import queue
 
-from .overlay import Overlay
+from dls_util.image import Overlay
 from .stream_action import StreamAction
 from dls_util.image import Image
 from dls_util.cv import CameraStream

dls_barcode/camera/plate_overlay.py

@@ -0,0 +1,23 @@
+from dls_util.image import Overlay, Image, Color
+
+
+class PlateOverlay(Overlay):
+    """ Represents an overlay that can be drawn on top of an image. Used to draw the outline of a plate
+    on the continuous scanner camera image to highlight to the user which barcodes on the plate have
+    already been scanned.
+    """
+    def __init__(self, plate, options, lifetime=2):
+        Overlay.__init__(self, lifetime)
+
+        self._plate = plate
+        self._options = options
+
+    def draw_on_image(self, img):
+        """ Draw the plate highlight  to the image.
+        """
+        image = Image(img)
+
+        # If the overlay has not expired, draw on the plate highlight and/or the status message
+        if not self.has_expired():
+            self._plate.draw_plate(image, Color.Blue())
+            self._plate.draw_pins(image, self._options)

dls_barcode/camera/scanner_worker.py

@@ -0,0 +1,90 @@
+import time
+
+from dls_util.image import Image
+from dls_util.message import MessageType, Message
+from dls_util import Beeper
+from dls_barcode.scan import GeometryScanner, SlotScanner, OpenScanner
+from dls_barcode.datamatrix import DataMatrix
+from .camera_position import CameraPosition
+from .plate_overlay import PlateOverlay
+
+NO_PUCK_TIME = 2
+
+
+class ScannerWorker:
+    """ Scan images for barcodes, combining partial scans until a full puck is reached.
+    Keep the record of the last scan which was at least partially successful (aligned geometry
+    and some barcodes scanned). For each new frame, we can attempt to merge the results with
+    this previous plates so that we don't have to re-read any of the previously captured barcodes
+    (because this is a relatively expensive operation).
+    """
+    def run(self, task_queue, overlay_queue, result_queue, message_queue, kill_queue, config, cam_position):
+        print("SCANNER start")
+        self._last_plate_time = time.time()
+
+        SlotScanner.DEBUG = config.slot_images.value()
+        SlotScanner.DEBUG_DIR = config.slot_image_directory.value()
+
+        self._create_scanner(cam_position, config)
+
+        display = True
+        while kill_queue.empty():
+            if display:
+                print("--- scanner inside loop")
+                display = False
+
+            if task_queue.empty():
+                continue
+
+            frame = task_queue.get(True)
+            self._process_frame(frame, config, overlay_queue, result_queue, message_queue)
+
+        print("SCANNER stop & kill")
+
+    def _process_frame(self, frame, config, overlay_queue, result_queue, message_queue):
+        image = Image(frame)
+        gray_image = image.to_grayscale()
+
+        # If we have an existing partial plate, merge the new plate with it and only try to read the
+        # barcodes which haven't already been read. This significantly increases efficiency because
+        # barcode read is expensive.
+        scan_result = self._scanner.scan_next_frame(gray_image)
+
+        if config.console_frame.value():
+            scan_result.print_summary()
+
+        if scan_result.success():
+            # Record the time so we can see how long its been since we last saw a plate
+            self._last_plate_time = time.time()
+
+            plate = scan_result.plate()
+            if scan_result.any_valid_barcodes():
+                overlay_queue.put(PlateOverlay(plate, config))
+                self._plate_beep(plate, config.scan_beep.value())
+
+            if scan_result.any_new_barcodes():
+                result_queue.put((plate, image))
+        elif scan_result.error() is not None and (time.time() - self._last_plate_time > NO_PUCK_TIME):
+            message_queue.put(Message(MessageType.WARNING, scan_result.error(), lifetime=1))
+
+    def _create_scanner(self, cam_position, config):
+        if cam_position == CameraPosition.SIDE:
+            plate_type = "None"
+            barcode_sizes = DataMatrix.DEFAULT_SIDE_SIZES
+        else:
+            plate_type = config.plate_type.value()
+            barcode_sizes = [config.top_barcode_size.value()]
+
+        if plate_type == "None":
+            self._scanner = OpenScanner(barcode_sizes)
+        else:
+            self._scanner = GeometryScanner(plate_type, barcode_sizes)
+
+    def _plate_beep(self, plate, do_beep):
+        if not do_beep:
+            return
+
+        empty_fraction = (plate.num_slots - plate.num_valid_barcodes()) / plate.num_slots
+        frequency = int(10000 * empty_fraction + 37)
+        duration = 200
+        Beeper.beep(frequency, duration)

dls_barcode/gui/image_frame.py

@@ -28,9 +28,9 @@ def _init_ui(self):
 
         self.setLayout(vbox)
 
-    def clear_frame(self):
+    def clear_frame(self, message):
         self._frame.clear()
-        self._frame.setText("No Scan Selected")
+        self._frame.setText(message)
 
     def display_puck_image(self, image):
         """ Called when a new row is selected on the record table. Displays the specified