Browse Source
This commit ports the work of EchterAgo and cculianu from Electron-Cash, to implement a new toolchain to scan qr codes. Previously, on Linux and Win, we have been using zbar to access the camera and read qrcodes; and on macOS we used CalinsQRReader (an objective-C project by cculianu). The new toolchain added here can use QtMultimedia to access the camera, and then feed that image into zbar. When used this way, zbar needs fewer dependencies and is easier to compile, in particular it can be compiled for macOS. The new toolchain works on all three platforms, with some caveats (see code comments in related commits) -- so we also keep the end-to-end zbar toolchain; but at least we can drop CalinsQRReader. The related changes in Electron-Cash are spread over 50+ commits (several PRs and direct pushes to master), but see in particular: https://github.com/Electron-Cash/Electron-Cash/pull/1376 some other interesting links:patch-4b2b737001c163224cf1f3b31e0fcb1eda015908ehttps://github.com/Electron-Cash/Electron-Cash/pull/1545052aa06c23
SomberNight
3 years ago
24 changed files with 1631 additions and 131 deletions
@ -1 +0,0 @@ |
|||
Subproject commit 59dfc03272751cd29ee311456fa34c40f7ebb7c0 |
|||
@ -0,0 +1,30 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from .camera_dialog import (QrReaderCameraDialog, CameraError, NoCamerasFound, |
|||
NoCameraResolutionsFound, MissingQrDetectionLib) |
|||
from .validator import (QrReaderValidatorResult, AbstractQrReaderValidator, |
|||
QrReaderValidatorCounting, QrReaderValidatorColorizing, |
|||
QrReaderValidatorStrong, QrReaderValidatorCounted) |
|||
@ -0,0 +1,461 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
import time |
|||
import math |
|||
import sys |
|||
import os |
|||
from typing import List |
|||
|
|||
from PyQt5.QtMultimedia import QCameraInfo, QCamera, QCameraViewfinderSettings |
|||
from PyQt5.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QCheckBox, QPushButton, QLabel |
|||
from PyQt5.QtGui import QImage, QPixmap |
|||
from PyQt5.QtCore import QSize, QRect, Qt, pyqtSignal, PYQT_VERSION |
|||
|
|||
from electrum.simple_config import SimpleConfig |
|||
from electrum.i18n import _ |
|||
from electrum.qrreader import get_qr_reader, QrCodeResult |
|||
from electrum.logging import Logger |
|||
|
|||
from .video_widget import QrReaderVideoWidget |
|||
from .video_overlay import QrReaderVideoOverlay |
|||
from .video_surface import QrReaderVideoSurface |
|||
from .crop_blur_effect import QrReaderCropBlurEffect |
|||
from .validator import AbstractQrReaderValidator, QrReaderValidatorCounted, QrReaderValidatorResult |
|||
from ..util import MessageBoxMixin, FixedAspectRatioLayout, ImageGraphicsEffect |
|||
|
|||
class CameraError(RuntimeError): |
|||
''' Base class of the camera-related error conditions. ''' |
|||
|
|||
class NoCamerasFound(CameraError): |
|||
''' Raised by start_scan if no usable cameras were found. Interested |
|||
code can catch this specific exception.''' |
|||
|
|||
class NoCameraResolutionsFound(CameraError): |
|||
''' Raised internally if no usable camera resolutions were found. ''' |
|||
|
|||
class MissingQrDetectionLib(RuntimeError): |
|||
''' Raised if we can't find zbar or whatever other platform lib |
|||
we require to detect QR in image frames. ''' |
|||
|
|||
class QrReaderCameraDialog(Logger, MessageBoxMixin, QDialog): |
|||
""" |
|||
Dialog for reading QR codes from a camera |
|||
""" |
|||
|
|||
# Try to crop so we have minimum 512 dimensions |
|||
SCAN_SIZE: int = 512 |
|||
|
|||
qr_finished = pyqtSignal(bool, str, object) |
|||
|
|||
def __init__(self, parent, *, config: SimpleConfig): |
|||
''' Note: make sure parent is a "top_level_window()" as per |
|||
MessageBoxMixin API else bad things can happen on macOS. ''' |
|||
QDialog.__init__(self, parent=parent) |
|||
Logger.__init__(self) |
|||
|
|||
self.validator: AbstractQrReaderValidator = None |
|||
self.frame_id: int = 0 |
|||
self.qr_crop: QRect = None |
|||
self.qrreader_res: List[QrCodeResult] = [] |
|||
self.validator_res: QrReaderValidatorResult = None |
|||
self.last_stats_time: float = 0.0 |
|||
self.frame_counter: int = 0 |
|||
self.qr_frame_counter: int = 0 |
|||
self.last_qr_scan_ts: float = 0.0 |
|||
self.camera: QCamera = None |
|||
self._error_message: str = None |
|||
self._ok_done: bool = False |
|||
self.camera_sc_conn = None |
|||
self.resolution: QSize = None |
|||
|
|||
self.config = config |
|||
|
|||
# Try to get the QR reader for this system |
|||
self.qrreader = get_qr_reader() |
|||
if not self.qrreader: |
|||
raise MissingQrDetectionLib(_("The platform QR detection library is not available.")) |
|||
|
|||
# Set up the window, add the maximize button |
|||
flags = self.windowFlags() |
|||
flags = flags | Qt.WindowMaximizeButtonHint |
|||
self.setWindowFlags(flags) |
|||
self.setWindowTitle(_("Scan QR Code")) |
|||
self.setWindowModality(Qt.WindowModal if parent else Qt.ApplicationModal) |
|||
|
|||
# Create video widget and fixed aspect ratio layout to contain it |
|||
self.video_widget = QrReaderVideoWidget() |
|||
self.video_overlay = QrReaderVideoOverlay() |
|||
self.video_layout = FixedAspectRatioLayout() |
|||
self.video_layout.addWidget(self.video_widget) |
|||
self.video_layout.addWidget(self.video_overlay) |
|||
|
|||
# Create root layout and add the video widget layout to it |
|||
vbox = QVBoxLayout() |
|||
self.setLayout(vbox) |
|||
vbox.setContentsMargins(0, 0, 0, 0) |
|||
vbox.addLayout(self.video_layout) |
|||
|
|||
self.lowres_label = QLabel(_("Note: This camera generates frames of relatively low resolution; QR scanning accuracy may be affected")) |
|||
self.lowres_label.setWordWrap(True) |
|||
self.lowres_label.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter) |
|||
vbox.addWidget(self.lowres_label) |
|||
self.lowres_label.setHidden(True) |
|||
|
|||
# Create a layout for the controls |
|||
controls_layout = QHBoxLayout() |
|||
controls_layout.addStretch(2) |
|||
controls_layout.setContentsMargins(10, 10, 10, 10) |
|||
controls_layout.setSpacing(10) |
|||
vbox.addLayout(controls_layout) |
|||
|
|||
# Flip horizontally checkbox with default coming from global config |
|||
self.flip_x = QCheckBox() |
|||
self.flip_x.setText(_("&Flip horizontally")) |
|||
self.flip_x.setChecked(bool(self.config.get('qrreader_flip_x', True))) |
|||
self.flip_x.stateChanged.connect(self._on_flip_x_changed) |
|||
controls_layout.addWidget(self.flip_x) |
|||
|
|||
close_but = QPushButton(_("&Close")) |
|||
close_but.clicked.connect(self.reject) |
|||
controls_layout.addWidget(close_but) |
|||
|
|||
# Create the video surface and receive events when new frames arrive |
|||
self.video_surface = QrReaderVideoSurface(self) |
|||
self.video_surface.frame_available.connect(self._on_frame_available) |
|||
|
|||
# Create the crop blur effect |
|||
self.crop_blur_effect = QrReaderCropBlurEffect(self) |
|||
self.image_effect = ImageGraphicsEffect(self, self.crop_blur_effect) |
|||
|
|||
|
|||
# Note these should stay as queued connections becasue we use the idiom |
|||
# self.reject() and self.accept() in this class to kill the scan -- |
|||
# and we do it from within callback functions. If you don't use |
|||
# queued connections here, bad things can happen. |
|||
self.finished.connect(self._boilerplate_cleanup, Qt.QueuedConnection) |
|||
self.finished.connect(self._on_finished, Qt.QueuedConnection) |
|||
|
|||
def _on_flip_x_changed(self, _state: int): |
|||
self.config.set_key('qrreader_flip_x', self.flip_x.isChecked()) |
|||
|
|||
def _get_resolution(self, resolutions: List[QSize], min_size: int) -> QSize: |
|||
""" |
|||
Given a list of resolutions that the camera supports this function picks the |
|||
lowest resolution that is at least min_size in both width and height. |
|||
If no resolution is found, NoCameraResolutionsFound is raised. |
|||
""" |
|||
def res_list_to_str(res_list: List[QSize]) -> str: |
|||
return ', '.join(['{}x{}'.format(r.width(), r.height()) for r in res_list]) |
|||
|
|||
def check_res(res: QSize): |
|||
return res.width() >= min_size and res.height() >= min_size |
|||
|
|||
self.logger.info('searching for at least {0}x{0}'.format(min_size)) |
|||
|
|||
# Query and display all resolutions the camera supports |
|||
format_str = 'camera resolutions: {}' |
|||
self.logger.info(format_str.format(res_list_to_str(resolutions))) |
|||
|
|||
# Filter to those that are at least min_size in both width and height |
|||
candidate_resolutions = [] |
|||
ideal_resolutions = [r for r in resolutions if check_res(r)] |
|||
less_than_ideal_resolutions = [r for r in resolutions if r not in ideal_resolutions] |
|||
format_str = 'ideal resolutions: {}, less-than-ideal resolutions: {}' |
|||
self.logger.info(format_str.format(res_list_to_str(ideal_resolutions), res_list_to_str(less_than_ideal_resolutions))) |
|||
|
|||
# Raise an error if we have no usable resolutions |
|||
if not ideal_resolutions and not less_than_ideal_resolutions: |
|||
raise NoCameraResolutionsFound(_("Cannot start QR scanner, no usable camera resolution found.") + self._linux_pyqt5bug_msg()) |
|||
|
|||
if not ideal_resolutions: |
|||
self.logger.warning('No ideal resolutions found, falling back to less-than-ideal resolutions -- QR recognition may fail!') |
|||
candidate_resolutions = less_than_ideal_resolutions |
|||
is_ideal = False |
|||
else: |
|||
candidate_resolutions = ideal_resolutions |
|||
is_ideal = True |
|||
|
|||
|
|||
# Sort the usable resolutions, least number of pixels first, get the first element |
|||
resolution = sorted(candidate_resolutions, key=lambda r: r.width() * r.height(), reverse=not is_ideal)[0] |
|||
format_str = 'chosen resolution is {}x{}' |
|||
self.logger.info(format_str.format(resolution.width(), resolution.height())) |
|||
|
|||
return resolution, is_ideal |
|||
|
|||
@staticmethod |
|||
def _get_crop(resolution: QSize, scan_size: int) -> QRect: |
|||
""" |
|||
Returns a QRect that is scan_size x scan_size in the middle of the resolution |
|||
""" |
|||
scan_pos_x = (resolution.width() - scan_size) / 2 |
|||
scan_pos_y = (resolution.height() - scan_size) / 2 |
|||
return QRect(scan_pos_x, scan_pos_y, scan_size, scan_size) |
|||
|
|||
@staticmethod |
|||
def _linux_pyqt5bug_msg(): |
|||
''' Returns a string that may be appended to an exception error message |
|||
only if on Linux and PyQt5 < 5.12.2, otherwise returns an empty string. ''' |
|||
if (sys.platform == 'linux' and PYQT_VERSION < 0x050c02 # Check if PyQt5 < 5.12.2 on linux |
|||
# Also: this warning is not relevant to APPIMAGE; so make sure |
|||
# we are not running from APPIMAGE. |
|||
and not os.environ.get('APPIMAGE')): |
|||
# In this case it's possible we couldn't detect a camera because |
|||
# of that missing libQt5MultimediaGstTools.so problem. |
|||
return ("\n\n" + _('If you indeed do have a usable camera connected, then this error may be caused by bugs in previous PyQt5 versions on Linux. Try installing the latest PyQt5:') |
|||
+ "\n\n" + "python3 -m pip install --user -I pyqt5") |
|||
return '' |
|||
|
|||
def start_scan(self, device: str = ''): |
|||
""" |
|||
Scans a QR code from the given camera device. |
|||
If no QR code is found the returned string will be empty. |
|||
If the camera is not found or can't be opened NoCamerasFound will be raised. |
|||
""" |
|||
|
|||
self.validator = QrReaderValidatorCounted() |
|||
self.validator.strong_count = 5 # FIXME: make this time based rather than framect based |
|||
|
|||
device_info = None |
|||
|
|||
for camera in QCameraInfo.availableCameras(): |
|||
if camera.deviceName() == device: |
|||
device_info = camera |
|||
break |
|||
|
|||
if not device_info: |
|||
self.logger.info('Failed to open selected camera, trying to use default camera') |
|||
device_info = QCameraInfo.defaultCamera() |
|||
|
|||
if not device_info or device_info.isNull(): |
|||
raise NoCamerasFound(_("Cannot start QR scanner, no usable camera found.") + self._linux_pyqt5bug_msg()) |
|||
|
|||
self._init_stats() |
|||
self.qrreader_res = [] |
|||
self.validator_res = None |
|||
self._ok_done = False |
|||
self._error_message = None |
|||
|
|||
if self.camera: |
|||
self.logger.info("Warning: start_scan already called for this instance.") |
|||
|
|||
self.camera = QCamera(device_info) |
|||
self.camera.setViewfinder(self.video_surface) |
|||
self.camera.setCaptureMode(QCamera.CaptureViewfinder) |
|||
|
|||
# this operates on camera from within the signal handler, so should be a queued connection |
|||
self.camera_sc_conn = self.camera.statusChanged.connect(self._on_camera_status_changed, Qt.QueuedConnection) |
|||
self.camera.error.connect(self._on_camera_error) # log the errors we get, if any, for debugging |
|||
# Camera needs to be loaded to query resolutions, this tries to open the camera |
|||
self.camera.load() |
|||
|
|||
_camera_status_names = { |
|||
QCamera.UnavailableStatus: _('unavailable'), |
|||
QCamera.UnloadedStatus: _('unloaded'), |
|||
QCamera.UnloadingStatus: _('unloading'), |
|||
QCamera.LoadingStatus: _('loading'), |
|||
QCamera.LoadedStatus: _('loaded'), |
|||
QCamera.StandbyStatus: _('standby'), |
|||
QCamera.StartingStatus: _('starting'), |
|||
QCamera.StoppingStatus: _('stopping'), |
|||
QCamera.ActiveStatus: _('active') |
|||
} |
|||
|
|||
def _get_camera_status_name(self, status: QCamera.Status): |
|||
return self._camera_status_names.get(status, _('unknown')) |
|||
|
|||
def _set_resolution(self, resolution: QSize): |
|||
self.resolution = resolution |
|||
self.qr_crop = self._get_crop(resolution, self.SCAN_SIZE) |
|||
|
|||
# Initialize the video widget |
|||
#self.video_widget.setMinimumSize(resolution) # <-- on macOS this makes it fixed size for some reason. |
|||
self.resize(720, 540) |
|||
self.video_overlay.set_crop(self.qr_crop) |
|||
self.video_overlay.set_resolution(resolution) |
|||
self.video_layout.set_aspect_ratio(resolution.width() / resolution.height()) |
|||
|
|||
# Set up the crop blur effect |
|||
self.crop_blur_effect.setCrop(self.qr_crop) |
|||
|
|||
def _on_camera_status_changed(self, status: QCamera.Status): |
|||
if self._ok_done: |
|||
# camera/scan is quitting, abort. |
|||
return |
|||
|
|||
self.logger.info('camera status changed to {}'.format(self._get_camera_status_name(status))) |
|||
|
|||
if status == QCamera.LoadedStatus: |
|||
# Determine the optimal resolution and compute the crop rect |
|||
camera_resolutions = self.camera.supportedViewfinderResolutions() |
|||
try: |
|||
resolution, was_ideal = self._get_resolution(camera_resolutions, self.SCAN_SIZE) |
|||
except RuntimeError as e: |
|||
self._error_message = str(e) |
|||
self.reject() |
|||
return |
|||
self._set_resolution(resolution) |
|||
|
|||
# Set the camera resolution |
|||
viewfinder_settings = QCameraViewfinderSettings() |
|||
viewfinder_settings.setResolution(resolution) |
|||
self.camera.setViewfinderSettings(viewfinder_settings) |
|||
|
|||
# Counter for the QR scanner frame number |
|||
self.frame_id = 0 |
|||
|
|||
self.camera.start() |
|||
self.lowres_label.setVisible(not was_ideal) # if they have a low res camera, show the warning label. |
|||
elif status == QCamera.UnloadedStatus or status == QCamera.UnavailableStatus: |
|||
self._error_message = _("Cannot start QR scanner, camera is unavailable.") |
|||
self.reject() |
|||
elif status == QCamera.ActiveStatus: |
|||
self.open() |
|||
|
|||
CameraErrorStrings = { |
|||
QCamera.NoError : "No Error", |
|||
QCamera.CameraError : "Camera Error", |
|||
QCamera.InvalidRequestError : "Invalid Request Error", |
|||
QCamera.ServiceMissingError : "Service Missing Error", |
|||
QCamera.NotSupportedFeatureError : "Unsupported Feature Error" |
|||
} |
|||
def _on_camera_error(self, errorCode): |
|||
errStr = self.CameraErrorStrings.get(errorCode, "Unknown Error") |
|||
self.logger.info(f"QCamera error: {errStr}") |
|||
|
|||
def accept(self): |
|||
self._ok_done = True # immediately blocks further processing |
|||
super().accept() |
|||
|
|||
def reject(self): |
|||
self._ok_done = True # immediately blocks further processing |
|||
super().reject() |
|||
|
|||
def _boilerplate_cleanup(self): |
|||
self._close_camera() |
|||
if self.isVisible(): |
|||
self.close() |
|||
|
|||
def _close_camera(self): |
|||
if self.camera: |
|||
self.camera.setViewfinder(None) |
|||
if self.camera_sc_conn: |
|||
self.camera.statusChanged.disconnect(self.camera_sc_conn) |
|||
self.camera_sc_conn = None |
|||
self.camera.unload() |
|||
self.camera = None |
|||
|
|||
def _on_finished(self, code): |
|||
res = ( (code == QDialog.Accepted |
|||
and self.validator_res and self.validator_res.accepted |
|||
and self.validator_res.simple_result) |
|||
or '' ) |
|||
|
|||
self.validator = None |
|||
|
|||
self.logger.info(f'closed {res}') |
|||
|
|||
self.qr_finished.emit(code == QDialog.Accepted, self._error_message, res) |
|||
|
|||
def _on_frame_available(self, frame: QImage): |
|||
if self._ok_done: |
|||
return |
|||
|
|||
self.frame_id += 1 |
|||
|
|||
if frame.size() != self.resolution: |
|||
self.logger.info('Getting video data at {}x{} instead of the requested {}x{}, switching resolution.'.format( |
|||
frame.size().width(), frame.size().height(), |
|||
self.resolution.width(), self.resolution.height() |
|||
)) |
|||
self._set_resolution(frame.size()) |
|||
|
|||
flip_x = self.flip_x.isChecked() |
|||
|
|||
# Only QR scan every QR_SCAN_PERIOD secs |
|||
qr_scanned = time.time() - self.last_qr_scan_ts >= self.qrreader.interval() |
|||
if qr_scanned: |
|||
self.last_qr_scan_ts = time.time() |
|||
# Crop the frame so we only scan a SCAN_SIZE rect |
|||
frame_cropped = frame.copy(self.qr_crop) |
|||
|
|||
# Convert to Y800 / GREY FourCC (single 8-bit channel) |
|||
# This creates a copy, so we don't need to keep the frame around anymore |
|||
frame_y800 = frame_cropped.convertToFormat(QImage.Format_Grayscale8) |
|||
|
|||
# Read the QR codes from the frame |
|||
self.qrreader_res = self.qrreader.read_qr_code( |
|||
frame_y800.constBits().__int__(), frame_y800.byteCount(), |
|||
frame_y800.bytesPerLine(), |
|||
frame_y800.width(), |
|||
frame_y800.height(), self.frame_id |
|||
) |
|||
|
|||
# Call the validator to see if the scanned results are acceptable |
|||
self.validator_res = self.validator.validate_results(self.qrreader_res) |
|||
|
|||
# Update the video overlay with the results |
|||
self.video_overlay.set_results(self.qrreader_res, flip_x, self.validator_res) |
|||
|
|||
# Close the dialog if the validator accepted the result |
|||
if self.validator_res.accepted: |
|||
self.accept() |
|||
return |
|||
|
|||
# Apply the crop blur effect |
|||
if self.image_effect: |
|||
frame = self.image_effect.apply(frame) |
|||
|
|||
# If horizontal flipping is enabled, only flip the display |
|||
if flip_x: |
|||
frame = frame.mirrored(True, False) |
|||
|
|||
# Display the frame in the widget |
|||
self.video_widget.setPixmap(QPixmap.fromImage(frame)) |
|||
|
|||
self._update_stats(qr_scanned) |
|||
|
|||
def _init_stats(self): |
|||
self.last_stats_time = time.perf_counter() |
|||
self.frame_counter = 0 |
|||
self.qr_frame_counter = 0 |
|||
|
|||
def _update_stats(self, qr_scanned): |
|||
self.frame_counter += 1 |
|||
if qr_scanned: |
|||
self.qr_frame_counter += 1 |
|||
now = time.perf_counter() |
|||
last_stats_delta = now - self.last_stats_time |
|||
if last_stats_delta > 1.0: # stats every 1.0 seconds |
|||
fps = self.frame_counter / last_stats_delta |
|||
qr_fps = self.qr_frame_counter / last_stats_delta |
|||
if self.validator is not None: |
|||
self.validator.strong_count = math.ceil(qr_fps / 3) # 1/3 of a second's worth of qr frames determines strong_count |
|||
stats_format = 'running at {} FPS, scanner at {} FPS' |
|||
self.logger.info(stats_format.format(fps, qr_fps)) |
|||
self.frame_counter = 0 |
|||
self.qr_frame_counter = 0 |
|||
self.last_stats_time = now |
|||
@ -0,0 +1,77 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from PyQt5.QtWidgets import QGraphicsBlurEffect, QGraphicsEffect |
|||
from PyQt5.QtGui import QPainter, QTransform, QRegion |
|||
from PyQt5.QtCore import QObject, QRect, QPoint, Qt |
|||
|
|||
|
|||
class QrReaderCropBlurEffect(QGraphicsBlurEffect): |
|||
CROP_OFFSET_ENABLED = False |
|||
CROP_OFFSET = QPoint(5, 5) |
|||
|
|||
BLUR_DARKEN = 0.25 |
|||
BLUR_RADIUS = 8 |
|||
|
|||
def __init__(self, parent: QObject, crop: QRect = None): |
|||
super().__init__(parent) |
|||
self.crop = crop |
|||
self.setBlurRadius(self.BLUR_RADIUS) |
|||
|
|||
def setCrop(self, crop: QRect = None): |
|||
self.crop = crop |
|||
|
|||
def draw(self, painter: QPainter): |
|||
assert self.crop, 'crop must be set' |
|||
|
|||
# Compute painter regions for the crop and the blur |
|||
all_region = QRegion(painter.viewport()) |
|||
crop_region = QRegion(self.crop) |
|||
blur_region = all_region.subtracted(crop_region) |
|||
|
|||
# Let the QGraphicsBlurEffect only paint in blur_region |
|||
painter.setClipRegion(blur_region) |
|||
|
|||
# Fill with black and set opacity so that the blurred region is drawn darker |
|||
if self.BLUR_DARKEN > 0.0: |
|||
painter.fillRect(painter.viewport(), Qt.black) |
|||
painter.setOpacity(1 - self.BLUR_DARKEN) |
|||
|
|||
# Draw the blur effect |
|||
super().draw(painter) |
|||
|
|||
# Restore clipping and opacity |
|||
painter.setClipping(False) |
|||
painter.setOpacity(1.0) |
|||
|
|||
# Get the source pixmap |
|||
pixmap, offset = self.sourcePixmap(Qt.DeviceCoordinates, QGraphicsEffect.NoPad) |
|||
painter.setWorldTransform(QTransform()) |
|||
|
|||
# Get the source by adding the offset to the crop location |
|||
source = self.crop |
|||
if self.CROP_OFFSET_ENABLED: |
|||
source = source.translated(self.CROP_OFFSET) |
|||
painter.drawPixmap(self.crop.topLeft() + offset, pixmap, source) |
|||
@ -0,0 +1,166 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from typing import List, Dict, Callable, Any |
|||
from abc import ABC, abstractmethod |
|||
|
|||
from PyQt5.QtGui import QColor |
|||
from PyQt5.QtCore import Qt |
|||
|
|||
from electrum.i18n import _ |
|||
from electrum.qrreader import QrCodeResult |
|||
|
|||
from electrum.gui.qt.util import ColorScheme, QColorLerp |
|||
|
|||
|
|||
class QrReaderValidatorResult(): |
|||
""" |
|||
Result of a QR code validator |
|||
""" |
|||
|
|||
def __init__(self): |
|||
self.accepted: bool = False |
|||
|
|||
self.message: str = None |
|||
self.message_color: QColor = None |
|||
|
|||
self.simple_result : str = None |
|||
|
|||
self.result_usable: Dict[QrCodeResult, bool] = {} |
|||
self.result_colors: Dict[QrCodeResult, QColor] = {} |
|||
self.result_messages: Dict[QrCodeResult, str] = {} |
|||
|
|||
self.selected_results: List[QrCodeResult] = [] |
|||
|
|||
|
|||
class AbstractQrReaderValidator(ABC): |
|||
""" |
|||
Abstract base class for QR code result validators. |
|||
""" |
|||
|
|||
@abstractmethod |
|||
def validate_results(self, results: List[QrCodeResult]) -> QrReaderValidatorResult: |
|||
""" |
|||
Checks a list of QR code results for usable codes. |
|||
""" |
|||
|
|||
class QrReaderValidatorCounting(AbstractQrReaderValidator): |
|||
""" |
|||
This QR code result validator doesn't directly accept any results but maintains a dictionary |
|||
of detection counts in `result_counts`. |
|||
""" |
|||
|
|||
result_counts: Dict[QrCodeResult, int] = {} |
|||
|
|||
def validate_results(self, results: List[QrCodeResult]) -> QrReaderValidatorResult: |
|||
res = QrReaderValidatorResult() |
|||
|
|||
for result in results: |
|||
# Increment the detection count |
|||
if not result in self.result_counts: |
|||
self.result_counts[result] = 0 |
|||
self.result_counts[result] += 1 |
|||
|
|||
# Search for missing results, iterate over a copy because the loop might modify the dict |
|||
for result in self.result_counts.copy(): |
|||
# Count down missing results |
|||
if result in results: |
|||
continue |
|||
self.result_counts[result] -= 2 |
|||
# When the count goes to zero, remove |
|||
if self.result_counts[result] < 1: |
|||
del self.result_counts[result] |
|||
|
|||
return res |
|||
|
|||
class QrReaderValidatorColorizing(QrReaderValidatorCounting): |
|||
""" |
|||
This QR code result validator doesn't directly accept any results but colorizes the results |
|||
based on the counts maintained by `QrReaderValidatorCounting`. |
|||
""" |
|||
|
|||
WEAK_COLOR: QColor = QColor(Qt.red) |
|||
STRONG_COLOR: QColor = QColor(Qt.green) |
|||
|
|||
strong_count: int = 10 |
|||
|
|||
def validate_results(self, results: List[QrCodeResult]) -> QrReaderValidatorResult: |
|||
res = super().validate_results(results) |
|||
|
|||
# Colorize the QR code results by their detection counts |
|||
for result in results: |
|||
# Enforce strong_count as upper limit |
|||
self.result_counts[result] = min(self.result_counts[result], self.strong_count) |
|||
|
|||
# Interpolate between WEAK_COLOR and STRONG_COLOR based on count / strong_count |
|||
lerp_factor = (self.result_counts[result] - 1) / self.strong_count |
|||
lerped_color = QColorLerp(self.WEAK_COLOR, self.STRONG_COLOR, lerp_factor) |
|||
res.result_colors[result] = lerped_color |
|||
|
|||
return res |
|||
|
|||
class QrReaderValidatorStrong(QrReaderValidatorColorizing): |
|||
""" |
|||
This QR code result validator doesn't directly accept any results but passes every strong |
|||
detection in the return values `selected_results`. |
|||
""" |
|||
|
|||
def validate_results(self, results: List[QrCodeResult]) -> QrReaderValidatorResult: |
|||
res = super().validate_results(results) |
|||
|
|||
for result in results: |
|||
if self.result_counts[result] >= self.strong_count: |
|||
res.selected_results.append(result) |
|||
break |
|||
|
|||
return res |
|||
|
|||
class QrReaderValidatorCounted(QrReaderValidatorStrong): |
|||
""" |
|||
This QR code result validator accepts a result as soon as there is at least `minimum` and at |
|||
most `maximum` QR code(s) with strong detection. |
|||
""" |
|||
|
|||
def __init__(self, minimum: int = 1, maximum: int = 1): |
|||
super().__init__() |
|||
self.minimum = minimum |
|||
self.maximum = maximum |
|||
|
|||
def validate_results(self, results: List[QrCodeResult]) -> QrReaderValidatorResult: |
|||
res = super().validate_results(results) |
|||
|
|||
num_results = len(res.selected_results) |
|||
if num_results < self.minimum: |
|||
if num_results > 0: |
|||
res.message = _('Too few QR codes detected.') |
|||
res.message_color = ColorScheme.RED.as_color() |
|||
elif num_results > self.maximum: |
|||
res.message = _('Too many QR codes detected.') |
|||
res.message_color = ColorScheme.RED.as_color() |
|||
else: |
|||
res.accepted = True |
|||
res.simple_result = (results and results[0].data) or '' # hack added by calin just to take the first one |
|||
|
|||
return res |
|||
@ -0,0 +1,157 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from typing import List |
|||
|
|||
from PyQt5.QtWidgets import QWidget |
|||
from PyQt5.QtGui import QPainter, QPaintEvent, QPen, QPainterPath, QColor, QTransform |
|||
from PyQt5.QtCore import QPoint, QSize, QRect, QRectF, Qt |
|||
|
|||
from electrum.qrreader import QrCodeResult |
|||
|
|||
from .validator import QrReaderValidatorResult |
|||
|
|||
|
|||
class QrReaderVideoOverlay(QWidget): |
|||
""" |
|||
Overlays the QR scanner results over the video |
|||
""" |
|||
|
|||
BG_RECT_PADDING = 10 |
|||
BG_RECT_CORNER_RADIUS = 10.0 |
|||
BG_RECT_OPACITY = 0.75 |
|||
|
|||
def __init__(self, parent: QWidget = None): |
|||
super().__init__(parent) |
|||
|
|||
self.results = [] |
|||
self.flip_x = False |
|||
self.validator_results = None |
|||
self.crop = None |
|||
self.resolution = None |
|||
|
|||
self.qr_outline_pen = QPen() |
|||
self.qr_outline_pen.setColor(Qt.red) |
|||
self.qr_outline_pen.setWidth(3) |
|||
self.qr_outline_pen.setStyle(Qt.DotLine) |
|||
|
|||
self.text_pen = QPen() |
|||
self.text_pen.setColor(Qt.black) |
|||
|
|||
self.bg_rect_pen = QPen() |
|||
self.bg_rect_pen.setColor(Qt.black) |
|||
self.bg_rect_pen.setStyle(Qt.DotLine) |
|||
self.bg_rect_fill = QColor(255, 255, 255, 255 * self.BG_RECT_OPACITY) |
|||
|
|||
def set_results(self, results: List[QrCodeResult], flip_x: bool, |
|||
validator_results: QrReaderValidatorResult): |
|||
self.results = results |
|||
self.flip_x = flip_x |
|||
self.validator_results = validator_results |
|||
self.update() |
|||
|
|||
def set_crop(self, crop: QRect): |
|||
self.crop = crop |
|||
|
|||
def set_resolution(self, resolution: QSize): |
|||
self.resolution = resolution |
|||
|
|||
def paintEvent(self, _event: QPaintEvent): |
|||
if not self.crop or not self.resolution: |
|||
return |
|||
|
|||
painter = QPainter(self) |
|||
|
|||
# Keep a backup of the transform and create a new one |
|||
transform = painter.worldTransform() |
|||
|
|||
# Set scaling transform |
|||
transform = transform.scale(self.width() / self.resolution.width(), |
|||
self.height() / self.resolution.height()) |
|||
|
|||
# Compute the transform to flip the coordinate system on the x axis |
|||
transform_flip = QTransform() |
|||
if self.flip_x: |
|||
transform_flip = transform_flip.translate(self.resolution.width(), 0.0) |
|||
transform_flip = transform_flip.scale(-1.0, 1.0) |
|||
|
|||
# Small helper for tuple to QPoint |
|||
def toqp(point): |
|||
return QPoint(point[0], point[1]) |
|||
|
|||
# Starting from here we care about AA |
|||
painter.setRenderHint(QPainter.Antialiasing) |
|||
|
|||
# Draw all the QR code results |
|||
for res in self.results: |
|||
painter.setWorldTransform(transform_flip * transform, False) |
|||
|
|||
# Draw lines between all of the QR code points |
|||
pen = QPen(self.qr_outline_pen) |
|||
if res in self.validator_results.result_colors: |
|||
pen.setColor(self.validator_results.result_colors[res]) |
|||
painter.setPen(pen) |
|||
num_points = len(res.points) |
|||
for i in range(0, num_points): |
|||
i_n = i + 1 |
|||
|
|||
line_from = toqp(res.points[i]) |
|||
line_from += self.crop.topLeft() |
|||
|
|||
line_to = toqp(res.points[i_n] if i_n < num_points else res.points[0]) |
|||
line_to += self.crop.topLeft() |
|||
|
|||
painter.drawLine(line_from, line_to) |
|||
|
|||
# Draw the QR code data |
|||
# Note that we reset the world transform to only the scaled transform |
|||
# because otherwise the text could be flipped. We only use transform_flip |
|||
# to map the center point of the result. |
|||
painter.setWorldTransform(transform, False) |
|||
font_metrics = painter.fontMetrics() |
|||
data_metrics = QSize(font_metrics.horizontalAdvance(res.data), font_metrics.capHeight()) |
|||
|
|||
center_pos = toqp(res.center) |
|||
center_pos += self.crop.topLeft() |
|||
center_pos = transform_flip.map(center_pos) |
|||
|
|||
text_offset = QPoint(data_metrics.width(), data_metrics.height()) |
|||
text_offset = text_offset / 2 |
|||
text_offset.setX(-text_offset.x()) |
|||
center_pos += text_offset |
|||
|
|||
padding = self.BG_RECT_PADDING |
|||
bg_rect_pos = center_pos - QPoint(padding, data_metrics.height() + padding) |
|||
bg_rect_size = data_metrics + (QSize(padding, padding) * 2) |
|||
bg_rect = QRect(bg_rect_pos, bg_rect_size) |
|||
bg_rect_path = QPainterPath() |
|||
radius = self.BG_RECT_CORNER_RADIUS |
|||
bg_rect_path.addRoundedRect(QRectF(bg_rect), radius, radius, Qt.AbsoluteSize) |
|||
painter.setPen(self.bg_rect_pen) |
|||
painter.fillPath(bg_rect_path, self.bg_rect_fill) |
|||
painter.drawPath(bg_rect_path) |
|||
|
|||
painter.setPen(self.text_pen) |
|||
painter.drawText(center_pos, res.data) |
|||
@ -0,0 +1,91 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from typing import List |
|||
|
|||
from PyQt5.QtMultimedia import (QVideoFrame, QAbstractVideoBuffer, QAbstractVideoSurface, |
|||
QVideoSurfaceFormat) |
|||
from PyQt5.QtGui import QImage |
|||
from PyQt5.QtCore import QObject, pyqtSignal |
|||
|
|||
from electrum.i18n import _ |
|||
from electrum.logging import get_logger |
|||
|
|||
|
|||
_logger = get_logger(__name__) |
|||
|
|||
|
|||
class QrReaderVideoSurface(QAbstractVideoSurface): |
|||
""" |
|||
Receives QVideoFrames from QCamera, converts them into a QImage, flips the X and Y axis if |
|||
necessary and sends them to listeners via the frame_available event. |
|||
""" |
|||
|
|||
def __init__(self, parent: QObject = None): |
|||
super().__init__(parent) |
|||
|
|||
def present(self, frame: QVideoFrame) -> bool: |
|||
if not frame.isValid(): |
|||
return False |
|||
|
|||
image_format = QVideoFrame.imageFormatFromPixelFormat(frame.pixelFormat()) |
|||
if image_format == QVideoFrame.Format_Invalid: |
|||
_logger.info(_('QR code scanner for video frame with invalid pixel format')) |
|||
return False |
|||
|
|||
if not frame.map(QAbstractVideoBuffer.ReadOnly): |
|||
_logger.info(_('QR code scanner failed to map video frame')) |
|||
return False |
|||
|
|||
try: |
|||
img = QImage(frame.bits(), frame.width(), frame.height(), image_format) |
|||
|
|||
# Check whether we need to flip the image on any axis |
|||
surface_format = self.surfaceFormat() |
|||
flip_x = surface_format.isMirrored() |
|||
flip_y = surface_format.scanLineDirection() == QVideoSurfaceFormat.BottomToTop |
|||
|
|||
# Mirror the image if needed |
|||
if flip_x or flip_y: |
|||
img = img.mirrored(flip_x, flip_y) |
|||
|
|||
# Create a copy of the image so the original frame data can be freed |
|||
img = img.copy() |
|||
finally: |
|||
frame.unmap() |
|||
|
|||
self.frame_available.emit(img) |
|||
|
|||
return True |
|||
|
|||
def supportedPixelFormats(self, handle_type: QAbstractVideoBuffer.HandleType) -> List[QVideoFrame.PixelFormat]: |
|||
if handle_type == QAbstractVideoBuffer.NoHandle: |
|||
# We support all pixel formats that can be understood by QImage directly |
|||
return [QVideoFrame.Format_ARGB32, QVideoFrame.Format_ARGB32_Premultiplied, |
|||
QVideoFrame.Format_RGB32, QVideoFrame.Format_RGB24, QVideoFrame.Format_RGB565, |
|||
QVideoFrame.Format_RGB555, QVideoFrame.Format_ARGB8565_Premultiplied] |
|||
return [] |
|||
|
|||
frame_available = pyqtSignal(QImage) |
|||
@ -0,0 +1,52 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from PyQt5.QtWidgets import QWidget |
|||
from PyQt5.QtGui import QPixmap, QPainter, QPaintEvent |
|||
|
|||
|
|||
class QrReaderVideoWidget(QWidget): |
|||
""" |
|||
Simple widget for drawing a pixmap |
|||
""" |
|||
|
|||
USE_BILINEAR_FILTER = True |
|||
|
|||
def __init__(self, parent: QWidget = None): |
|||
super().__init__(parent) |
|||
|
|||
self.pixmap = None |
|||
|
|||
def paintEvent(self, _event: QPaintEvent): |
|||
if not self.pixmap: |
|||
return |
|||
painter = QPainter(self) |
|||
if self.USE_BILINEAR_FILTER: |
|||
painter.setRenderHint(QPainter.SmoothPixmapTransform) |
|||
painter.drawPixmap(self.rect(), self.pixmap, self.pixmap.rect()) |
|||
|
|||
def setPixmap(self, pixmap: QPixmap): |
|||
self.pixmap = pixmap |
|||
self.update() |
|||
@ -0,0 +1,61 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
from typing import Optional |
|||
|
|||
from ..logging import get_logger |
|||
|
|||
from .abstract_base import AbstractQrCodeReader, QrCodeResult |
|||
|
|||
|
|||
_logger = get_logger(__name__) |
|||
|
|||
|
|||
class MissingLib(RuntimeError): |
|||
''' Raised by underlying implementation if missing libs ''' |
|||
pass |
|||
|
|||
|
|||
def get_qr_reader() -> Optional[AbstractQrCodeReader]: |
|||
""" |
|||
Get the Qr code reader for the current platform |
|||
""" |
|||
try: |
|||
from .zbar import ZbarQrCodeReader |
|||
return ZbarQrCodeReader() |
|||
""" |
|||
# DEBUG CODE BELOW |
|||
# If you want to test this code on a platform that doesn't yet work or have |
|||
# zbar, use the below... |
|||
class Fake(AbstractQrCodeReader): |
|||
def read_qr_code(self, buffer, buffer_size, dummy, width, height, frame_id = -1): |
|||
''' fake noop to test ''' |
|||
return [] |
|||
return Fake() |
|||
""" |
|||
except MissingLib as e: |
|||
_logger.exception("") |
|||
|
|||
return None |
|||
@ -0,0 +1,77 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
import ctypes |
|||
from typing import List, Tuple |
|||
from abc import ABC, abstractmethod |
|||
|
|||
QrCodePoint = Tuple[int, int] |
|||
QrCodePointList = List[QrCodePoint] |
|||
|
|||
|
|||
class QrCodeResult(): |
|||
""" |
|||
A detected QR code. |
|||
""" |
|||
def __init__(self, data: str, center: QrCodePoint, points: QrCodePointList): |
|||
self.data: str = data |
|||
self.center: QrCodePoint = center |
|||
self.points: QrCodePointList = points |
|||
|
|||
def __str__(self) -> str: |
|||
return 'data: {} center: {} points: {}'.format(self.data, self.center, self.points) |
|||
|
|||
def __hash__(self): |
|||
return hash(self.data) |
|||
|
|||
def __eq__(self, other): |
|||
return self.data == other.data |
|||
|
|||
def __ne__(self, other): |
|||
return not self == other |
|||
|
|||
class AbstractQrCodeReader(ABC): |
|||
""" |
|||
Abstract base class for QR code readers. |
|||
""" |
|||
|
|||
def interval(self) -> float: |
|||
''' Reimplement to specify a time (in seconds) that the implementation |
|||
recommends elapse between subsequent calls to read_qr_code. |
|||
Implementations that have very expensive and/or slow detection code |
|||
may want to rate-limit read_qr_code calls by overriding this function. |
|||
e.g.: to make detection happen every 200ms, you would return 0.2 here. |
|||
Defaults to 0.0''' |
|||
return 0.0 |
|||
|
|||
@abstractmethod |
|||
def read_qr_code(self, buffer: ctypes.c_void_p, |
|||
buffer_size: int, # overall image size in bytes |
|||
rowlen_bytes: int, # the scan line length in bytes. (many libs, such as OSX, expect this value to properly grok image data) |
|||
width: int, height: int, frame_id: int = -1) -> List[QrCodeResult]: |
|||
""" |
|||
Reads a QR code from an image buffer in Y800 / GREY format. |
|||
Returns a list of detected QR codes which includes their data and positions. |
|||
""" |
|||
@ -0,0 +1,183 @@ |
|||
#!/usr/bin/env python3 |
|||
# |
|||
# Electron Cash - lightweight Bitcoin client |
|||
# Copyright (C) 2019 Axel Gembe <derago@gmail.com> |
|||
# |
|||
# Permission is hereby granted, free of charge, to any person |
|||
# obtaining a copy of this software and associated documentation files |
|||
# (the "Software"), to deal in the Software without restriction, |
|||
# including without limitation the rights to use, copy, modify, merge, |
|||
# publish, distribute, sublicense, and/or sell copies of the Software, |
|||
# and to permit persons to whom the Software is furnished to do so, |
|||
# subject to the following conditions: |
|||
# |
|||
# The above copyright notice and this permission notice shall be |
|||
# included in all copies or substantial portions of the Software. |
|||
# |
|||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
# SOFTWARE. |
|||
|
|||
import sys |
|||
import ctypes |
|||
import os |
|||
from typing import List |
|||
from enum import IntEnum |
|||
|
|||
from ..logging import get_logger |
|||
|
|||
from . import MissingLib |
|||
from .abstract_base import AbstractQrCodeReader, QrCodeResult |
|||
|
|||
|
|||
_logger = get_logger(__name__) |
|||
|
|||
|
|||
if sys.platform == 'darwin': |
|||
LIBNAME = 'libzbar.0.dylib' |
|||
elif sys.platform in ('windows', 'win32'): |
|||
LIBNAME = 'libzbar-0.dll' |
|||
else: |
|||
LIBNAME = 'libzbar.so.0' |
|||
|
|||
try: |
|||
try: |
|||
LIBZBAR = ctypes.cdll.LoadLibrary(os.path.join(os.path.dirname(__file__), '..', LIBNAME)) |
|||
except OSError as e: |
|||
LIBZBAR = ctypes.cdll.LoadLibrary(LIBNAME) |
|||
|
|||
LIBZBAR.zbar_image_create.restype = ctypes.c_void_p |
|||
LIBZBAR.zbar_image_scanner_create.restype = ctypes.c_void_p |
|||
LIBZBAR.zbar_image_scanner_get_results.restype = ctypes.c_void_p |
|||
LIBZBAR.zbar_symbol_set_first_symbol.restype = ctypes.c_void_p |
|||
LIBZBAR.zbar_symbol_get_data.restype = ctypes.POINTER(ctypes.c_char_p) |
|||
LIBZBAR.zbar_image_scanner_set_config.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int, ctypes.c_int] |
|||
LIBZBAR.zbar_image_set_sequence.argtypes = [ctypes.c_void_p, ctypes.c_int] |
|||
LIBZBAR.zbar_image_set_size.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int] |
|||
LIBZBAR.zbar_image_set_format.argtypes = [ctypes.c_void_p, ctypes.c_int] |
|||
LIBZBAR.zbar_image_set_data.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p] |
|||
LIBZBAR.zbar_image_scanner_recycle_image.argtypes = [ctypes.c_void_p, ctypes.c_void_p] |
|||
LIBZBAR.zbar_scan_image.argtypes = [ctypes.c_void_p, ctypes.c_void_p] |
|||
LIBZBAR.zbar_image_scanner_get_results.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_symbol_set_first_symbol.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_symbol_get_data_length.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_symbol_get_data.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_symbol_get_loc_size.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_symbol_get_loc_x.argtypes = [ctypes.c_void_p, ctypes.c_int] |
|||
LIBZBAR.zbar_symbol_get_loc_y.argtypes = [ctypes.c_void_p, ctypes.c_int] |
|||
LIBZBAR.zbar_symbol_next.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_image_scanner_destroy.argtypes = [ctypes.c_void_p] |
|||
LIBZBAR.zbar_image_destroy.argtypes = [ctypes.c_void_p] |
|||
|
|||
#if is_verbose: |
|||
#LIBZBAR.zbar_set_verbosity(100) |
|||
except OSError: |
|||
_logger.exception("Failed to load zbar") |
|||
LIBZBAR = None |
|||
|
|||
FOURCC_Y800 = 0x30303859 |
|||
|
|||
@ctypes.CFUNCTYPE(None, ctypes.c_void_p) |
|||
def zbar_cleanup(image): |
|||
""" |
|||
Do nothing, this is just so zbar doesn't try to manage our QImage buffers |
|||
""" |
|||
|
|||
class ZbarSymbolType(IntEnum): |
|||
""" |
|||
Supported symbol types, see zbar_symbol_type_e in zbar.h |
|||
""" |
|||
EAN2 = 2 |
|||
EAN5 = 5 |
|||
EAN8 = 8 |
|||
UPCE = 9 |
|||
ISBN10 = 10 |
|||
UPCA = 12 |
|||
EAN13 = 13 |
|||
ISBN13 = 14 |
|||
COMPOSITE = 15 |
|||
I25 = 25 |
|||
DATABAR = 34 |
|||
DATABAR_EXP = 35 |
|||
CODABAR = 38 |
|||
CODE39 = 39 |
|||
PDF417 = 57 |
|||
QRCODE = 64 |
|||
SQCODE = 80 |
|||
CODE93 = 93 |
|||
CODE128 = 128 |
|||
|
|||
class ZbarConfig(IntEnum): |
|||
""" |
|||
Supported configuration options, see zbar_config_e in zbar.h |
|||
""" |
|||
ENABLE = 0 |
|||
|
|||
class ZbarQrCodeReader(AbstractQrCodeReader): |
|||
""" |
|||
Reader that uses libzbar |
|||
""" |
|||
|
|||
def __init__(self): |
|||
if not LIBZBAR: |
|||
raise MissingLib('Zbar library not found') |
|||
# Set up zbar |
|||
self.zbar_scanner = LIBZBAR.zbar_image_scanner_create() |
|||
self.zbar_image = LIBZBAR.zbar_image_create() |
|||
|
|||
# Disable all symbols |
|||
for sym_type in ZbarSymbolType: |
|||
LIBZBAR.zbar_image_scanner_set_config(self.zbar_scanner, sym_type, ZbarConfig.ENABLE, 0) |
|||
|
|||
# Enable only QR codes |
|||
LIBZBAR.zbar_image_scanner_set_config(self.zbar_scanner, ZbarSymbolType.QRCODE, |
|||
ZbarConfig.ENABLE, 1) |
|||
|
|||
def __del__(self): |
|||
if LIBZBAR: |
|||
LIBZBAR.zbar_image_scanner_destroy(self.zbar_scanner) |
|||
LIBZBAR.zbar_image_destroy(self.zbar_image) |
|||
|
|||
def read_qr_code(self, buffer: ctypes.c_void_p, buffer_size: int, |
|||
rowlen_bytes: int, # this param is ignored in this implementation |
|||
width: int, height: int, frame_id: int = -1) -> List[QrCodeResult]: |
|||
LIBZBAR.zbar_image_set_sequence(self.zbar_image, frame_id) |
|||
LIBZBAR.zbar_image_set_size(self.zbar_image, width, height) |
|||
LIBZBAR.zbar_image_set_format(self.zbar_image, FOURCC_Y800) |
|||
LIBZBAR.zbar_image_set_data(self.zbar_image, buffer, buffer_size, zbar_cleanup) |
|||
LIBZBAR.zbar_image_scanner_recycle_image(self.zbar_scanner, self.zbar_image) |
|||
LIBZBAR.zbar_scan_image(self.zbar_scanner, self.zbar_image) |
|||
|
|||
result_set = LIBZBAR.zbar_image_scanner_get_results(self.zbar_scanner) |
|||
|
|||
res = [] |
|||
symbol = LIBZBAR.zbar_symbol_set_first_symbol(result_set) |
|||
while symbol: |
|||
symbol_data_len = LIBZBAR.zbar_symbol_get_data_length(symbol) |
|||
symbol_data_ptr = LIBZBAR.zbar_symbol_get_data(symbol) |
|||
symbol_data_bytes = ctypes.string_at(symbol_data_ptr, symbol_data_len) |
|||
symbol_data = symbol_data_bytes.decode('utf-8') |
|||
|
|||
symbol_loc = [] |
|||
symbol_loc_len = LIBZBAR.zbar_symbol_get_loc_size(symbol) |
|||
for i in range(0, symbol_loc_len): |
|||
# Normalize the coordinates into 0..1 range by dividing by width / height |
|||
symbol_loc_x = LIBZBAR.zbar_symbol_get_loc_x(symbol, i) |
|||
symbol_loc_y = LIBZBAR.zbar_symbol_get_loc_y(symbol, i) |
|||
symbol_loc.append((symbol_loc_x, symbol_loc_y)) |
|||
|
|||
# Find the center by getting the average values of the corners x and y coordinates |
|||
symbol_loc_sum_x = sum([l[0] for l in symbol_loc]) |
|||
symbol_loc_sum_y = sum([l[1] for l in symbol_loc]) |
|||
symbol_loc_center = (int(symbol_loc_sum_x / symbol_loc_len), int(symbol_loc_sum_y / symbol_loc_len)) |
|||
|
|||
res.append(QrCodeResult(symbol_data, symbol_loc_center, symbol_loc)) |
|||
|
|||
symbol = LIBZBAR.zbar_symbol_next(symbol) |
|||
|
|||
return res |
|||
Loading…
Reference in new issue