initial simplification

Author: UrszulaNeuman

dls_barcode/datamatrix/datamatrix.py

@@ -1,11 +1,7 @@
+from dls_util.image.image import Image
 from .locate import Locator
-from .read import DatamatrixSizeTable
-from .read import DatamatrixReaderError, ReedSolomonError
-from .read import DatamatrixBitReader
-from .read import DatamatrixByteExtractor
-from .read import ReedSolomonDecoder
-from .read import DatamatrixByteInterpreter
 from pylibdmtx.pylibdmtx import decode
+import cv2
 
 
 # We predict the location of the center of each square (pixel/bit) in the datamatrix based on the
@@ -29,10 +25,7 @@ class DataMatrix:
     DEFAULT_SIZE = 14
     DEFAULT_SIDE_SIZES = [12, 14]
 
-    _w = 0.25
-    DIAG_WIGGLES = [[0, 0], [_w, _w], [-_w, -_w], [_w, -_w], [-_w, _w]]
-
-    def __init__(self, finder_pattern, image):
+    def __init__(self, finder_pattern):
         """ Initialize the DataMatrix object with its finder pattern location in an image. To actually
         interpret the DataMatrix, the perform_read() function must be called, which will attempt to read
         the DM from the supplied image.
@@ -42,7 +35,6 @@ def __init__(self, finder_pattern, image):
         error correction bytes).
         """
         self._finder_pattern = finder_pattern
-        self._image = image.img
         self._matrix_sizes = [self.DEFAULT_SIZE]
 
         self._data = None
@@ -54,14 +46,15 @@ def __init__(self, finder_pattern, image):
     def set_matrix_sizes(self, matrix_sizes):
         self._matrix_sizes = [int(v) for v in matrix_sizes]
 
-    def perform_read(self, offsets=wiggle_offsets, force_read=False):
+    def perform_read(self, image, force_read=False):
         """ Attempt to read the DataMatrix from the image supplied in the constructor at the position
         given by the finder pattern. This is not performed automatically upon construction because the
         read operation is relatively expensive and might not always be needed.
         """
         if not self._is_read_performed or force_read:
             # Read the data contained in the barcode from the image
-            self._read(self._image, offsets)
+            sub, _ = image.sub_image(self.center(), 1.2*self.radius())
+            self._read(sub.img)
             self._is_read_performed = True
 
     def is_read(self):
@@ -91,7 +84,7 @@ def data(self):
             return self._data
         else:
             return ''
-
+    
     def bounds(self):
         """ A circle which bounds the data matrix (center, radius). """
         return self._finder_pattern.bounds()
@@ -103,65 +96,31 @@ def center(self):
     def radius(self):
         """ The radius (center-to-corner distance) of the DataMatrix finder pattern. """
         return self._finder_pattern.radius
-
-    def _read(self, gray_image, offsets):
-        if self.radius() >= 0.2*(gray_image.shape[0]):
-            self._read_single(gray_image)
-        else:
-            self._read_old(gray_image, offsets)
-            
-    def _read_old(self, gray_image, offsets):
+        
+    def _read(self, gray_image):
         """ From the supplied grayscale image, attempt to read the barcode at the location
         given by the datamatrix finder pattern.
         """
-        for matrix_size in self._matrix_sizes:
-            bit_reader = DatamatrixBitReader(matrix_size)
-            extractor = DatamatrixByteExtractor()
-            decoder = ReedSolomonDecoder()
-            interpreter = DatamatrixByteInterpreter()
-
-            message_length = DatamatrixSizeTable.num_data_bytes(matrix_size)
-
-            # Try a few different small offsets for the sample positions until we find one that works
-            for offset in offsets:
-                # Read the bit array at the target location (with offset)
-                # If the bit array is valid, decode it and create a datamatrix object
-                try:
-                    bit_array = bit_reader.read_bit_array(self._finder_pattern, offset, gray_image)
-                    encoded_bytes = extractor.extract_bytes(bit_array)
-                    decoded_bytes = decoder.decode(encoded_bytes, message_length)
-                    data = interpreter.interpret_bytes(decoded_bytes)
-
-                    self._data = data
-                    self._read_ok = True
-                    self._error_message = ""
-                    break
-                except (DatamatrixReaderError, ReedSolomonError) as ex:
-                    self._read_ok = False
-                    self._error_message = str(ex)
-
-            self._damaged_symbol = not self._read_ok
-
-            if self._read_ok:
-                break
-        
-    def _read_single(self, gray_image):
         try:
-            result = decode(gray_image)
+            
+            cv2.imshow("Erode", gray_image)
+            cv2.waitKey(0) 
+            result = decode(gray_image, max_count = 1)
             if len(result) > 0:
                 d = result[0].data
                 decoded = d.decode('UTF-8')
                 new_line_removed = decoded.replace("\n","")
                 self._data = new_line_removed
                 self._read_ok = True
-                self._is_read_performed = True
                 self._error_message = ""
             else:
                 self._read_ok = False
         except(Exception) as ex:
             self._read_ok = False
             self._error_message = str(ex)
 
+        self._damaged_symbol = not self._read_ok
+        
     def draw(self, img, color):
         """ Draw the lines of the finder pattern on the specified image. """
         fp = self._finder_pattern
@@ -174,7 +133,7 @@ def locate_all_barcodes_in_image(grayscale_img, matrix_sizes=[DEFAULT_SIZE]):
         """
         locator = Locator()
         finder_patterns = locator.locate_shallow(grayscale_img)
-        unread_barcodes = DataMatrix._fps_to_barcodes(grayscale_img, finder_patterns, matrix_sizes)
+        unread_barcodes = DataMatrix._fps_to_barcodes(finder_patterns, matrix_sizes)
         return unread_barcodes
 
     @staticmethod
@@ -185,12 +144,12 @@ def locate_all_barcodes_in_image_deep(grayscale_img, matrix_sizes=[DEFAULT_SIDE_
         locator = Locator()
         locator.set_median_radius_tolerance(0.2)
         finder_patterns = locator.locate_deep(grayscale_img, expected_radius=None, filter_overlap=True)
-        unread_barcodes = DataMatrix._fps_to_barcodes(grayscale_img, finder_patterns, matrix_sizes)
+        unread_barcodes = DataMatrix._fps_to_barcodes(finder_patterns, matrix_sizes)
         return unread_barcodes
 
     @staticmethod
-    def _fps_to_barcodes(grayscale_img, finder_patterns, matrix_sizes):
-        unread_barcodes = [DataMatrix(fp, grayscale_img) for fp in finder_patterns]
+    def _fps_to_barcodes(finder_patterns, matrix_sizes):
+        unread_barcodes = [DataMatrix(fp) for fp in finder_patterns]
         for bc in unread_barcodes:
             bc.set_matrix_sizes(matrix_sizes)
         return list(unread_barcodes)

dls_barcode/plate/slot.py

@@ -37,6 +37,9 @@ def barcode(self):
 
     def state(self):
         return self._state
+    
+    def total_frames(self):
+        return self._total_frames
 
     def barcode_position(self):
         """ Get the position (x,y) of the center of the barcode (not exactly the same as the
@@ -77,3 +80,9 @@ def barcode_data(self):
             return self._barcode.data()
         else:
             return NOT_FOUND_SLOT_SYMBOL
+
+    def find_matching_barcode(self, barcodes):
+        for bc in barcodes:
+            if self._bounds.contains_point(bc.center()):
+                return bc
+        return None

dls_barcode/scan/open/open_scanner.py

@@ -57,7 +57,7 @@ def _perform_frame_scan(self):
         barcodes = self._locate_all_barcodes_in_image()
 
         for barcode in barcodes:
-            barcode.perform_read(DataMatrix.DIAG_WIGGLES)
+            barcode.perform_read(self._frame_img)
 
             if self._is_barcode_new(barcode):
                 # todo: limit number of previous barcodes stored

dls_barcode/scan/with_geometry/geometry_scanner.py

@@ -3,14 +3,12 @@
 
 
 from dls_barcode.datamatrix import DataMatrix
-from dls_barcode.geometry.exception import GeometryAlignmentError
 from dls_barcode.geometry.unipuck_locator import UnipuckLocator
 from dls_barcode.plate import Plate, Slot
 from dls_barcode.plate.geometry_adjuster import UnipuckGeometryAdjuster, GeometryAdjustmentError
 from dls_barcode.geometry import Geometry, GeometryException
 from .empty_detector import EmptySlotDetector
 from .plate_scanner import PlateScanner
-from .slot_scanner import SlotScanner
 from ..scan_result import ScanResult
 from ..no_barcodes_detected_error import NoBarcodesDetectedError
 
@@ -106,29 +104,16 @@ def _calculate_geometry(self):
         return geometry
 
     def _initialize_plate_from_barcodes(self):
-       
-        for bc in self._barcodes:
-            bc.perform_read()
-        
-        if self._any_valid_barcodes():
-            slot_scanner = self._create_slot_scanner()
+        if self._frame_img is not None:
             self._plate = Plate(self.plate_type)
             self._plate_scan = PlateScanner(self._plate, self._is_single_image)
-            self._plate_scan.new_frame(self._geometry, self._barcodes, slot_scanner)
+            self._plate_scan.new_frame(self._frame_img, self._geometry, self._barcodes)
 
     def _merge_frame_into_plate(self):
         # If one of the barcodes matches the previous frame and is aligned in the same slot, then we can
         # be fairly sure we are dealing with the same plate. Copy all of the barcodes that we read in the
         # previous plate over to their slot in the new plate. Then read any that we haven't already read.
-        slot_scanner = self._create_slot_scanner()
-        self._plate_scan.new_frame(self._geometry, self._barcodes, slot_scanner)
-
-    def _any_valid_barcodes(self):
-        return any([bc.is_read() and bc.is_valid() for bc in self._barcodes])
-
-    def _create_slot_scanner(self):
-        slot_scanner = SlotScanner(self._frame_img, self._barcodes)
-        return slot_scanner
+        self._plate_scan.new_frame(self._geometry, self._barcodes)
 
     def _find_common_barcode(self, geometry, barcodes):
         """ Determine if the set of finder patterns has any barcodes in common with the existing plate.

dls_barcode/scan/with_geometry/plate_scanner.py

@@ -1,22 +1,21 @@
-import random
+import numpy as np
+import cv2
 
-from dls_barcode.plate.slot import Slot
+from dls_barcode.scan.with_geometry.slot_scanner import SlotScanner
 
 
 class BadGeometryException(Exception):
     pass
 
 
 class PlateScanner:
-    FRAMES_BEFORE_DEEP = 3
+    BRIGHTNESS_RATIO = 5
 
-    def __init__(self, plate, single_frame=False):
+    def __init__(self,  plate, single_frame=False):
         self._plate = plate
-
-        self._frame_num = -1
         self._force_deep_scan = single_frame
 
-    def new_frame(self, geometry, barcodes, slot_scanner):
+    def new_frame(self, frame_img, geometry, barcodes):
         """ Merge the set of barcodes from a new scan into the plate. The new set comes from a new image
         of the same plate, so will almost certainly contain many of the same barcodes. Actually reading a
         barcode is relatively expensive; we iterate through each slot in the plate and only attempt to
@@ -27,79 +26,61 @@ def new_frame(self, geometry, barcodes, slot_scanner):
         position is likely to be similar to, but not exactly the same as, the bound's center. This info
         is retained as it allows us to properly calculate the geometry for future frames.
         """
-        self._frame_num += 1
+        self._frame_img = frame_img
+        self._barcodes = barcodes 
         self._plate.set_geometry(geometry)
+        
+        self.radius_avg = self._calculate_average_radius()
+        self.brightness_threshold = self._calculate_brightness_threshold()
 
         # Fill each slot with the correct barcodes
         for slot in self._plate.slots():
-            self._new_slot_frame(barcodes, slot, slot_scanner)
+            self._new_slot_frame(slot)
 
-    def _new_slot_frame(self, barcodes, slot, slot_scanner):
+    def _new_slot_frame(self, slot):
         slot.new_frame()
 
         # Find the barcode from the new set that is in the slot position
-        bounds = slot.bounds()
-        barcode = self._find_matching_barcode(bounds, barcodes)
-
-        # Update the barcode position - use the actual position of the barcode if available,
-        # otherwise use the slot center position (from geometry) as an approximation
-        position = barcode.center() if barcode else bounds.center()
+        barcode = slot.find_matching_barcode(self._barcodes)
+        position = barcode.center() if barcode else slot.bounds().center()
         slot.set_barcode_position(position)
-
-        # If we haven't already found this barcode data, try to read it from the new barcode
-        if slot.state() != Slot.VALID and barcode:
-            barcode.perform_read()
-            slot.set_barcode(barcode)
-
-        # If the barcode still hasn't been read, try a deeper slot scan
-        self._slot_scan(slot, slot_scanner)
-
-    @staticmethod
-    def _find_matching_barcode(slot_bounds, barcodes):
-        for bc in barcodes:
-            if slot_bounds.contains_point(bc.center()):
-                return bc
-        return None
-
-    def _slot_scan(self, slot, slot_scanner):
-        # If the slot barcode has already been read correctly, skip it
-        if slot.state() == Slot.VALID:
-            return
-
-        # Check for empty slot
-        if slot_scanner.is_slot_empty(slot):
-            slot.set_empty()
-            return
-
-        # Clear any previous (empty/unread) result
-        slot.set_no_result()
-
-        if self._should_do_deep_scan():
-            self._perform_deep_contour_slot_scan(slot, slot_scanner, self._force_deep_scan)
-            self._perform_square_slot_scan(slot, slot_scanner)
-
-    def _should_do_deep_scan(self):
-        return self._force_deep_scan or self._frame_num > self.FRAMES_BEFORE_DEEP
-
-    @staticmethod
-    def _perform_deep_contour_slot_scan(slot, slot_scanner, force_all):
-        if slot.state() != Slot.VALID:
-            barcodes = slot_scanner.deep_scan(slot)
-
-            # Pick a random finder pattern from those returned
-            if not force_all and barcodes:
-                barcodes = [random.choice(barcodes)]
-
-            for barcode in barcodes:
-                slot_scanner.wiggles_read(barcode, "DEEP CONTOUR")
-                slot.set_barcode(barcode)
-                if barcode.is_valid():
-                    break
-
-    @staticmethod
-    def _perform_square_slot_scan(slot, slot_scanner):
-        if slot.state() != Slot.VALID:
-            barcode = slot_scanner.square_scan(slot)
-            if barcode is not None:
-                slot_scanner.wiggles_read(barcode, "SQUARE")
-                slot.set_barcode(barcode)
+        
+        #slot_image = self._slot_image(slot)
+        #cv2.imshow("Slot image", slot_image.img)
+        #cv2.waitKey(0) 
+
+        slot_scanner = SlotScanner(self._frame_img, slot, barcode, self._force_deep_scan, self.radius_avg, self.brightness_threshold)
+        slot_scanner.scan_slot()
+    
+    def _calculate_average_radius(self):
+        if self._barcodes:
+            return np.mean([bc.radius() for bc in self._barcodes])
+        else:
+            return 0
+
+    def _image_contains_point(self, point, radius=0):
+        h, w = self._frame_img.img.shape
+        return (radius <= point.x <= w - radius - 1) and (radius <= point.y <= h - radius - 1)
+    
+    def _calculate_brightness_threshold(self):
+        """ Calculate the brightness of a small area at each barcode and return the average value.
+        A barcode will be much brighter than an empty slot as it usually contains plenty of white
+        pixels. This allows us to distinguish between an empty slot with no pin, and a slot with a pin
+        where we just haven't been able to locate the barcode.
+        """
+        pin_brights = []
+        for bc in self._barcodes:
+            size = bc.radius() / 2
+            center_in_frame = self._image_contains_point(bc.center(), radius=size)
+            if center_in_frame:
+                brightness = self._frame_img.calculate_brightness(bc.center(), size, size)
+                pin_brights.append(brightness)
+
+        if any(pin_brights):
+            avg_brightness = np.mean(pin_brights)
+        else:
+            avg_brightness = 0
+
+        return avg_brightness / self.BRIGHTNESS_RATIO
+
+