add logging

Author: UrszulaNeuman

dls_barcode/config/camera_config_control.py

@@ -1,3 +1,4 @@
+import logging
 import cv2
 from PyQt5.QtCore import Qt
 from PyQt5.QtWidgets import QLabel, QVBoxLayout, QHBoxLayout, QMessageBox, QLineEdit, QPushButton, QComboBox
@@ -15,6 +16,7 @@ def __init__(self, camera_config):
         ConfigControl.__init__(self, camera_config)
         self._camera_config = camera_config
         self._init_ui()
+        self.log = logging.getLogger(".".join([__name__]))
 
     def _init_ui(self):
         # Set Camera Number
@@ -60,9 +62,10 @@ def save_to_config(self):
     def _test_camera(self):
         self.save_to_config()
         try:
-           self._test_camera_settings()
-           self._display_camera_preview()
+            self._test_camera_settings()
+            self._display_camera_preview()
         except ValueError:
+            self.log.error("Camera Error - Cannot find specified camera")
             QMessageBox.critical(self, "Camera Error", "Cannot find specified camera")
 
 
@@ -79,6 +82,7 @@ def _test_camera_settings(self):
         stream.release_resources()
         if not read_ok:
             # Capture the next frame from the camera
+            self.log.error(ValueError("Read not OK"))
             raise ValueError
 
     def _display_camera_preview(self):

dls_barcode/datamatrix/datamatrix.py

@@ -1,3 +1,4 @@
+import logging
 from dls_util.image.image import Image
 from .locate import Locator
 from pylibdmtx.pylibdmtx import decode
@@ -42,6 +43,7 @@ def __init__(self, finder_pattern):
         self._read_ok = False
         self._damaged_symbol = False
         self._is_read_performed = False
+        self.log = logging.getLogger(".".join([__name__]))
 
     def set_matrix_sizes(self, matrix_sizes):
         self._matrix_sizes = [int(v) for v in matrix_sizes]
@@ -64,20 +66,23 @@ def is_read(self):
     def is_valid(self):
         """ True if the data matrix was read successfully. """
         if not self._is_read_performed:
+            self.log.debug("data matrix not read successfully")
             raise BarcodeReadNotPerformedException()
 
         return self._read_ok
 
     def is_unreadable(self):
         """ True if the data matrix could not be decoded (because of damage to the symbol). """
         if not self._is_read_performed:
+            self.log.debug("data matrix not read successfully")
             raise BarcodeReadNotPerformedException()
 
         return self._damaged_symbol
 
     def data(self):
         """ String representation of the barcode data. """
         if not self._is_read_performed:
+            self.log.debug("data matrix not read successfully")
             raise BarcodeReadNotPerformedException()
 
         if self._read_ok:
@@ -103,8 +108,7 @@ def _read(self, gray_image):
         """
         try:
 
-            cv2.imshow("Erode", gray_image)
-            cv2.waitKey(0) 
+
             result = decode(gray_image, max_count = 1)
             if len(result) > 0:
                 d = result[0].data
@@ -115,6 +119,8 @@ def _read(self, gray_image):
                 self._error_message = ""
             else:
                 self._read_ok = False
+                #cv2.imshow("Erode", gray_image)
+                #cv2.waitKey(0) 
         except(Exception) as ex:
             self._read_ok = False
             self._error_message = str(ex)

dls_barcode/datamatrix/locate/locate.py

@@ -72,8 +72,9 @@ def locate_deep(self, img, expected_radius=None, filter_overlap=False):
             finder_patterns = self._filter_overlapping_patterns(finder_patterns)
 
         # If the fps are asymmetrical, correct the side lengths
-        side = expected_radius * (2 / math.sqrt(2))
-        finder_patterns = [fp.correct_lengths(side) for fp in finder_patterns]
+        if expected_radius is not None:
+            side = expected_radius * (2 / math.sqrt(2))
+            finder_patterns = [fp.correct_lengths(side) for fp in finder_patterns]
 
         return finder_patterns
 

dls_barcode/datamatrix/locate/locate_contour.py

@@ -24,9 +24,13 @@ def locate_datamatrices(self, gray_image, blocksize, C, close_size):
         """
         # Perform adaptive threshold, reducing to a binary image
         threshold_image = self._do_threshold(gray_image, blocksize, C)
+        cv2.imshow("threshold", threshold_image.img)
+        cv2.waitKey(0) 
 
         # Perform a morphological close, removing noise and closing some gaps
         morphed_image = self._do_close_morph(threshold_image, close_size)
+        cv2.imshow("morph", threshold_image.img)
+        cv2.waitKey(0) 
 
         # Find a bunch of contours in the image.
         contours = self._get_contours(morphed_image)

dls_barcode/frame_processor.py

@@ -18,10 +18,10 @@ def __init__(self, side_camera_stream, side_frame) -> None:
     def run(self):
         side_result = self._side_camera_stream.process_frame(self._side_frame)
         if side_result.error() is not None:
-            self._log.debug(side_result.error().content())
+            # self._log.debug(side_result.error().content())
             self.side_scan_error_signal.emit(side_result.error())
         if side_result.has_valid_barcodes():
-            self._log.debug("side has valid barcodes")
+            # self._log.debug("side has valid barcodes")
             self.side_result_signal.emit(side_result)
 
         self.finished.emit()
@@ -39,7 +39,7 @@ def __init__(self, top_camera_stream, top_frame) -> None:
 
     def run(self):
         top_result = self._top_camera_stream.process_frame(self._top_frame)    
-                 
+
         if top_result.success():
             self.top_result_signal.emit(top_result)
             if top_result.is_full_valid():

dls_barcode/geometry/geometry.py

@@ -1,3 +1,4 @@
+import logging
 from .exception import GeometryException
 from .blank import BlankGeometry
 from .unipuck import Unipuck
@@ -46,8 +47,12 @@ def get_num_slots(geo_name):
 
     @staticmethod
     def _raise_not_implemented(geo_name):
+        log = logging.getLogger(".".join([__name__]))
+        log.debug(Geometry._MSG_NOT_IMPLEMENTED.format(geo_name))
         raise GeometryException(Geometry._MSG_NOT_IMPLEMENTED.format(geo_name))
 
     @staticmethod
     def _raise_unknown(geo_name):
+        log = logging.getLogger(".".join([__name__]))
+        log.debug(Geometry._MSG_UNKNOWN.format(geo_name))
         raise GeometryException(Geometry._MSG_UNKNOWN.format(geo_name))

dls_barcode/geometry/unipuck_calculator.py

@@ -1,4 +1,5 @@
 from __future__ import division
+import logging
 
 import time
 
@@ -32,13 +33,16 @@ def __init__(self, slot_centers):
         """
         self._num_slots = UnipuckTemplate.NUM_SLOTS
         self._slot_centers = slot_centers
+        self.log = logging.getLogger(".".join([__name__]))
 
     def perform_alignment(self):
         num_points = len(self._slot_centers)
 
         if num_points > self._num_slots:
+            self.log.debug("Too many slots detected to perform Unipuck alignment")
             raise GeometryAlignmentError("Too many slots detected to perform Unipuck alignment")
         elif num_points < MIN_POINTS_FOR_ALIGNMENT:
+            self.log.debug("Not enough slots detected to perform Unipuck alignment")
             raise GeometryAlignmentError("Not enough slots detected to perform Unipuck alignment")
 
         puck = self._calculate_puck_alignment()
@@ -58,6 +62,7 @@ def _calculate_puck_alignment(self):
             return puck
 
         except Exception:
+            self.log.error(GeometryAlignmentError("Unipuck alignment failed"))
             raise GeometryAlignmentError("Unipuck alignment failed")
 
     @staticmethod
@@ -125,6 +130,8 @@ def _determine_puck_orientation(puck, pin_centers):
 
         average_error = best_sse / (puck.radius() ** 2) / len(pin_centers)
         if average_error > 0.003:
+            log = logging.getLogger(".".join([__name__]))
+            log.debug("Unable to determine Unipuck orientation")
             raise GeometryAlignmentError("Unable to determine Unipuck orientation")
 
         return best_angle
@@ -179,6 +186,8 @@ def _partition(numbers):
     than the average of the first.
     """
     if len(numbers) < 3:
+        log = logging.getLogger(".".join([__name__]))
+        log.debug("Not enought elements to run partition")
         raise Exception("Not enought elements to run partition")
 
     numbers.sort()
@@ -187,6 +196,8 @@ def _partition(numbers):
 
     while s < len(numbers):
         if not numbers[:s + 1] or not numbers[-s - 1:]:
+            log = logging.getLogger(".".join([__name__]))
+            log.debug("Empty slice")
             raise Exception("Empty slice")
 
         gp1_average = np.mean(numbers[:s + 1])

dls_barcode/gui/main_window.py

@@ -207,12 +207,13 @@ def _load_store_records(self):
         self._record_table._load_store_records()
 
     def addRecordFrame(self, top_result, side_result):
-        holder_barcode = side_result.get_first_barcode().data()
-        plate = top_result.plate()
-        holder_image = side_result.get_frame_image()
-        pins_image = top_result.get_frame_image()
-        self._record_table.add_record_frame(holder_barcode, plate, holder_image, pins_image)
-        self._plate_beep(plate, self._config.get_scan_beep())
+        if top_result.error() is None:
+            holder_barcode = side_result.get_first_barcode().data()
+            plate = top_result.plate()
+            holder_image = side_result.get_frame_image()
+            pins_image = top_result.get_frame_image()
+            self._record_table.add_record_frame(holder_barcode, plate, holder_image, pins_image)
+            self._plate_beep(plate, self._config.get_scan_beep())
 
     def startCountdown(self, duration):
         self._log.debug("Countdown started")

dls_barcode/plate/geometry_adjuster.py

@@ -29,6 +29,7 @@ def adjust(self, plate, barcodes):
         # will cause this frame to be skipped).
         valid_barcodes = [bc for bc in barcodes if bc.is_read() and bc.is_valid()]
         if len(valid_barcodes) < 2:
+            log.debug("Geometry adjustment failed.")
             raise GeometryAdjustmentError("Geometry adjustment failed.")
 
         log.debug("ALIGNMENT ADJUSTMENT")  # DEBUG

dls_barcode/scan/open/open_scanner.py

@@ -1,3 +1,4 @@
+import logging
 from dls_barcode.camera.scanner_message import ScanErrorMessage
 from dls_barcode.datamatrix import DataMatrix
 
@@ -76,8 +77,9 @@ def _locate_all_barcodes_in_image(self):
             barcodes = DataMatrix.locate_all_barcodes_in_image_deep(self._frame_img, self.barcode_sizes)
         else:
             barcodes = DataMatrix.locate_all_barcodes_in_image(self._frame_img, self.barcode_sizes)
-        # TODO: log the error
         if len(barcodes) == 0:
+            # log = logging.getLogger(".".join([__name__]))
+            # log.error(NoBarcodesDetectedError())
             raise NoBarcodesDetectedError()
         return barcodes