Merge pull request #41 from DiamondLightSource/I04_1-150_improve_messages

I04 1 150 improve messages

Author: IsabellaRey

dls_barcode/camera/__init__.py

@@ -1,2 +1,3 @@
 from .camera_switch import CameraSwitch
 from .camera_scanner import CameraScanner
+from .scanner_message import NoNewBarcodeMessage, ScanErrorMessage

dls_barcode/camera/scanner_message.py

@@ -0,0 +1,10 @@
+class NoNewBarcodeMessage:
+    pass
+
+
+class ScanErrorMessage:
+    def __init__(self, content):
+        self._content = content
+
+    def content(self):
+        return self._content

dls_barcode/camera/scanner_worker.py

@@ -1,12 +1,12 @@
 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
+from .scanner_message import NoNewBarcodeMessage, ScanErrorMessage
 
 NO_PUCK_TIME = 2
 
@@ -20,7 +20,7 @@ class ScannerWorker:
     """
     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()
+        self._last_puck_time = time.time()
 
         SlotScanner.DEBUG = config.slot_images.value()
         SlotScanner.DEBUG_DIR = config.slot_image_directory.value()
@@ -54,8 +54,8 @@ def _process_frame(self, frame, config, overlay_queue, result_queue, message_que
             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()
+            # Record the time so we can see how long its been since we last saw a puck
+            self._last_puck_time = time.time()
 
             plate = scan_result.plate()
             if scan_result.any_valid_barcodes():
@@ -64,8 +64,12 @@ def _process_frame(self, frame, config, overlay_queue, result_queue, message_que
 
             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))
+        elif scan_result.any_valid_barcodes():
+            # We have read valid barcodes but they are not new, so the scanner didn't even output a plate
+            self._last_puck_time = time.time()
+            message_queue.put(NoNewBarcodeMessage())
+        elif scan_result.error() is not None and (time.time() - self._last_puck_time > NO_PUCK_TIME):
+            message_queue.put(ScanErrorMessage(scan_result.error()))
 
     def _create_scanner(self, cam_position, config):
         if cam_position == CameraPosition.SIDE:

dls_barcode/geometry/unipuck_calculator.py

@@ -34,10 +34,9 @@ def perform_alignment(self):
         num_points = len(self._slot_centers)
 
         if num_points > self._num_slots:
-            raise GeometryAlignmentError("Too many points to perform Unipuck alignment")
-
+            raise GeometryAlignmentError("Too many slots detected to perform Unipuck alignment")
         elif num_points < MIN_POINTS_FOR_ALIGNMENT:
-            raise GeometryAlignmentError("Not enough points to perform Unipuck alignment")
+            raise GeometryAlignmentError("Not enough slots detected to perform Unipuck alignment")
 
         puck = self._calculate_puck_alignment()
         return puck
@@ -57,8 +56,8 @@ def _calculate_puck_alignment(self):
 
             return puck
 
-        except Exception as ex:
-            raise GeometryAlignmentError("Unipuck Alignment failed")
+        except Exception:
+            raise GeometryAlignmentError("Unipuck alignment failed")
 
     @staticmethod
     def _find_puck_center(pin_centers):

dls_barcode/gui/main_window.py

@@ -1,17 +1,23 @@
 import multiprocessing
 import queue
+import time
 
 from PyQt4 import QtGui, QtCore
 
 from dls_barcode.config import BarcodeConfig, BarcodeConfigDialog
-from dls_barcode.camera import CameraScanner, CameraSwitch
+from dls_barcode.camera import CameraScanner, CameraSwitch, NoNewBarcodeMessage
 from dls_util import Beeper
 from dls_util.file import FileManager
-from dls_util.message import MessageType, Message
 from .barcode_table import BarcodeTable
 from .image_frame import ImageFrame
 from .record_table import ScanRecordTable
-from .message_display import MessageDisplay
+from .message_box import MessageBox
+from .message_factory import MessageFactory
+
+
+RESULT_TIMER_PERIOD = 1000 # ms
+VIEW_TIMER_PERIOD = 1 # ms
+MESSAGE_TIMER_PERIOD = 1 # ms
 
 
 class DiamondBarcodeMainWindow(QtGui.QMainWindow):
@@ -39,19 +45,20 @@ def __init__(self, config_file):
         self._view_queue = multiprocessing.Queue()
         self._message_queue = multiprocessing.Queue()
         self._initialise_scanner()
+        self._reset_msg_timer()
 
         # Timer that controls how often new scan results are looked for
         self._result_timer = QtCore.QTimer()
         self._result_timer.timeout.connect(self._read_result_queue)
-        self._result_timer.start(1000)
+        self._result_timer.start(RESULT_TIMER_PERIOD)
 
         self._view_timer = QtCore.QTimer()
         self._view_timer.timeout.connect(self._read_view_queue)
-        self._view_timer.start(1)
+        self._view_timer.start(VIEW_TIMER_PERIOD)
 
         self._message_timer = QtCore.QTimer()
         self._message_timer.timeout.connect(self._read_message_queue)
-        self._message_timer.start(1)
+        self._message_timer.start(MESSAGE_TIMER_PERIOD)
 
         self._camera_switch.restart_live_capture_from_side()
 
@@ -74,8 +81,8 @@ def _init_ui(self):
         self._record_table = ScanRecordTable(self._barcode_table, self._image_frame, self._config, self.on_record_table_clicked)
 
         # Message display
-        self._message_display = MessageDisplay()
-        self._message_display.setFixedHeight(64)
+        self._message_box = MessageBox()
+        self._message_box.setFixedHeight(64)
 
         # Open options first to make sure the cameras are set up correctly.
         # Start live capture of the side as soon as the dialog box is closed
@@ -89,7 +96,7 @@ def _init_ui(self):
 
         img_vbox = QtGui.QVBoxLayout()
         img_vbox.addWidget(self._image_frame)
-        img_vbox.addWidget(self._message_display)
+        img_vbox.addWidget(self._message_box)
         hbox.addLayout(img_vbox)
 
         vbox = QtGui.QVBoxLayout()
@@ -185,20 +192,46 @@ def _camera_capture_alive(self):
         return self._camera_scanner is not None and self._camera_switch is not None
 
     def _read_view_queue(self):
-        if not self._view_queue.empty():
-            try:
-                image = self._view_queue.get(False)
-                self._image_frame.display_puck_image(image)
-            except queue.Empty:
-                pass
+        if self._view_queue.empty():
+            return
+
+        try:
+            image = self._view_queue.get(False)
+        except queue.Empty:
+            return
+
+        self._image_frame.display_puck_image(image)
 
     def _read_message_queue(self):
-        if not self._message_queue.empty():
-            try:
-                message = self._message_queue.get(False)
-                self._message_display.display_message(message)
-            except queue.Empty:
-                return
+        if self._message_queue.empty():
+            return
+
+        try:
+            scanner_msg = self._message_queue.get(False)
+        except queue.Empty:
+            return
+
+        if self._camera_switch.is_side() and isinstance(scanner_msg, NoNewBarcodeMessage):
+            if not self._msg_timer_is_running():
+                # The result queue is read at a slower rate - use a timer to give it time to process a new barcode
+                self._start_msg_timer()
+            elif self._has_msg_timer_timeout():
+                self._message_box.display(MessageFactory.duplicate_barcode_message())
+        else:
+            self._reset_msg_timer()
+            self._message_box.display(MessageFactory.from_scanner_message(scanner_msg))
+
+    def _reset_msg_timer(self):
+        self._duplicate_msg_timer = None
+
+    def _start_msg_timer(self):
+        self._duplicate_msg_timer = time.time()
+
+    def _msg_timer_is_running(self):
+        return self._duplicate_msg_timer is not None
+
+    def _has_msg_timer_timeout(self):
+        return self._msg_timer_is_running() and time.time() - self._duplicate_msg_timer > 2 * RESULT_TIMER_PERIOD / 1000
 
     def _read_result_queue(self):
         """ Called every second; read any new results from the scan results queue, store them and display them.
@@ -222,17 +255,19 @@ def _read_side_scan(self):
 
         # Barcode successfully read
         Beeper.beep()
-        print("MAIN: holder barcode recorded")
+        print("MAIN: puck barcode recorded")
         if self._record_table.unique_side_barcode(plate): # if new side barcode
             self.original_plate = plate
             self._latest_holder_image = holder_image
-            self._message_display.display_message(Message(MessageType.INFO, "Plate barcode recorded"))
+            self._message_box.display(MessageFactory.puck_recorded_message())
             self._camera_switch.restart_live_capture_from_top()
+        else:
+            self._message_box.display(MessageFactory.duplicate_barcode_message())
 
     def _read_top_scan(self):
         if self._result_queue.empty():
             if self._camera_switch.is_top_scan_timeout():
-                self._message_display.display_message(Message(MessageType.INFO, "Scan timeout", lifetime=4))
+                self._message_box.display(MessageFactory.scan_timeout_message())
                 print("\n*** Scan timeout ***")
                 self._camera_switch.restart_live_capture_from_side()
             return
@@ -248,6 +283,6 @@ def _read_top_scan(self):
         # Barcodes successfully read
         Beeper.beep()
         print("Scan Completed")
-        self._message_display.display_message(Message(MessageType.INFO, "Scan completed"))
+        self._message_box.display(MessageFactory.scan_completed_message())
         self._camera_switch.restart_live_capture_from_side()
 

dls_barcode/gui/message_display.py dls_barcode/gui/message_box.pydls_barcode/gui/message_display.py renamed to dls_barcode/gui/message_box.py

@@ -7,10 +7,10 @@
 BLACK = "; color: black"
 BASIC_STYLE_SHEET = "font-size: 14pt"
 
-class MessageDisplay(QGroupBox):
+class MessageBox(QGroupBox):
     """GUI component. Displays messages for the user."""
     def __init__(self):
-        super(MessageDisplay, self).__init__()
+        super(MessageBox, self).__init__()
 
         self.setTitle("Information")
 
@@ -32,7 +32,7 @@ def _init_ui(self):
         vbox.addStretch()
         self.setLayout(vbox)
 
-    def display_message(self, message):
+    def display(self, message):
         self._message = message
         self._message_lbl.setText(self._message.content())
         self._message_lbl.setStyleSheet(self._style_sheets[self._message.type()])

dls_barcode/gui/message_factory.py

@@ -0,0 +1,23 @@
+from dls_util.message import MessageType, Message
+
+
+class MessageFactory:
+    @staticmethod
+    def duplicate_barcode_message():
+        return Message(MessageType.WARNING, "Puck barcode already in database", lifetime=3)
+
+    @staticmethod
+    def from_scanner_message(scanner_msg):
+        return Message(MessageType.WARNING, scanner_msg.content())
+
+    @staticmethod
+    def puck_recorded_message():
+        return Message(MessageType.INFO, "Puck barcode recorded")
+
+    @staticmethod
+    def scan_timeout_message():
+        return Message(MessageType.WARNING, "Scan timeout")
+
+    @staticmethod
+    def scan_completed_message():
+        return Message(MessageType.INFO, "Scan completed")

dls_barcode/plate/plate.py

@@ -18,7 +18,6 @@ def __init__(self, geometry_name, num_slots=-1):
         self.type = geometry_name
         self._geometry = None
 
-
         # Initialize slots
         self._slots = [Slot(i) for i in range(1, self.num_slots+1)]
 
@@ -37,7 +36,6 @@ def barcodes(self):
         """
         return [slot.barcode_data() for slot in self._slots]
 
-
     def geometry(self):
         return self._geometry
 

dls_barcode/scan/no_barcodes_detected_error.py

@@ -0,0 +1,3 @@
+class NoBarcodesDetectedError(Exception):
+    def __init__(self):
+        super(NoBarcodesDetectedError, self).__init__("No barcode detected")

dls_barcode/scan/open/open_scanner.py

@@ -2,13 +2,10 @@
 
 from dls_barcode.plate import Plate
 from dls_barcode.geometry import Geometry
+from ..no_barcodes_detected_error import NoBarcodesDetectedError
 from .open_scan_result import OpenScanResult
 
 
-class NoBarcodesError(Exception):
-    pass
-
-
 class OpenScanner:
     def __init__(self, barcode_sizes):
         self.plate_type = Geometry.NO_GEOMETRY
@@ -32,17 +29,17 @@ def scan_next_frame(self, frame_img, is_single_image=False):
         try:
             barcodes = self._perform_frame_scan()
             result.set_barcodes(barcodes)
-        except NoBarcodesError as ex:
+        except NoBarcodesDetectedError as ex:
             result.set_error(str(ex))
 
         # Create a 'blank' geometry object to store the barcode locations
         new_barcodes = result.new_barcodes()
-        num_barcodes = len(new_barcodes)
+        num_new_barcodes = len(new_barcodes)
         geometry = self._create_geometry(new_barcodes)
 
         # Create the plate
         if any(new_barcodes):
-            plate = Plate(self.plate_type, num_slots=num_barcodes)
+            plate = Plate(self.plate_type, num_slots=num_new_barcodes)
             plate.set_geometry(geometry)
             for s, barcode in enumerate(new_barcodes):
                 plate.slot(s).set_barcode(barcode)
@@ -76,7 +73,7 @@ def _locate_all_barcodes_in_image(self):
             barcodes = DataMatrix.locate_all_barcodes_in_image(self._frame_img, self.barcode_sizes)
 
         if len(barcodes) == 0:
-            raise NoBarcodesError("No Barcodes Detected In Image")
+            raise NoBarcodesDetectedError()
         return barcodes
 
     def _is_barcode_new(self, barcode):