ghost43
4 years ago
committed by
GitHub
GitHub
26 changed files with 1744 additions and 171 deletions
@ -1 +0,0 @@ |
|||
Subproject commit 59dfc03272751cd29ee311456fa34c40f7ebb7c0 |
|||
@ -0,0 +1,141 @@ |
|||
# Copyright (C) 2021 The Electrum developers |
|||
# Distributed under the MIT software license, see the accompanying |
|||
# file LICENCE or http://www.opensource.org/licenses/mit-license.php |
|||
# |
|||
# We have two toolchains to scan qr codes: |
|||
# 1. access camera via QtMultimedia, take picture, feed picture to zbar |
|||
# 2. let zbar handle whole flow (including accessing the camera) |
|||
# |
|||
# notes: |
|||
# - zbar needs to be compiled with platform-dependent extra config options to be able |
|||
# to access the camera |
|||
# - zbar fails to access the camera on macOS |
|||
# - qtmultimedia seems to support more cameras on Windows than zbar |
|||
# - qtmultimedia is often not packaged with PyQt5 |
|||
# in particular, on debian, you need both "python3-pyqt5" and "python3-pyqt5.qtmultimedia" |
|||
# - older versions of qtmultimedia don't seem to work reliably |
|||
# |
|||
# Considering the above, we use QtMultimedia for Windows and macOS, as there |
|||
# most users run our binaries where we can make sure the packaged versions work well. |
|||
# On Linux where many people run from source, we use zbar. |
|||
# |
|||
# Note: this module is safe to import on all platforms. |
|||
|
|||
import sys |
|||
from typing import Callable, Optional, TYPE_CHECKING, Mapping |
|||
|
|||
from PyQt5.QtWidgets import QMessageBox, QWidget |
|||
|
|||
from electrum.i18n import _ |
|||
from electrum.util import UserFacingException |
|||
from electrum.logging import get_logger |
|||
|
|||
from electrum.gui.qt.util import MessageBoxMixin, custom_message_box |
|||
|
|||
|
|||
if TYPE_CHECKING: |
|||
from electrum.simple_config import SimpleConfig |
|||
|
|||
|
|||
_logger = get_logger(__name__) |
|||
|
|||
|
|||
def scan_qrcode( |
|||
*, |
|||
parent: Optional[QWidget], |
|||
config: 'SimpleConfig', |
|||
callback: Callable[[bool, str, Optional[str]], None], |
|||
) -> None: |
|||
if sys.platform == 'darwin' or sys.platform in ('windows', 'win32'): |
|||
_scan_qrcode_using_qtmultimedia(parent=parent, config=config, callback=callback) |
|||
else: # desktop Linux and similar |
|||
_scan_qrcode_using_zbar(parent=parent, config=config, callback=callback) |
|||
|
|||
|
|||
def find_system_cameras() -> Mapping[str, str]: |
|||
"""Returns a camera_description -> camera_path map.""" |
|||
if sys.platform == 'darwin' or sys.platform in ('windows', 'win32'): |
|||
try: |
|||
from .qtmultimedia import find_system_cameras |
|||
except ImportError as e: |
|||
return {} |
|||
else: |
|||
return find_system_cameras() |
|||
else: # desktop Linux and similar |
|||
from electrum import qrscanner |
|||
return qrscanner.find_system_cameras() |
|||
|
|||
|
|||
# --- Internals below (not part of external API) |
|||
|
|||
def _scan_qrcode_using_zbar( |
|||
*, |
|||
parent: Optional[QWidget], |
|||
config: 'SimpleConfig', |
|||
callback: Callable[[bool, str, Optional[str]], None], |
|||
) -> None: |
|||
from electrum import qrscanner |
|||
data = None |
|||
try: |
|||
data = qrscanner.scan_barcode(config.get_video_device()) |
|||
except UserFacingException as e: |
|||
success = False |
|||
error = str(e) |
|||
except BaseException as e: |
|||
_logger.exception('camera error') |
|||
success = False |
|||
error = repr(e) |
|||
else: |
|||
success = True |
|||
error = "" |
|||
callback(success, error, data) |
|||
|
|||
|
|||
# Use a global to prevent multiple QR dialogs created simultaneously |
|||
_qr_dialog = None |
|||
|
|||
|
|||
def _scan_qrcode_using_qtmultimedia( |
|||
*, |
|||
parent: Optional[QWidget], |
|||
config: 'SimpleConfig', |
|||
callback: Callable[[bool, str, Optional[str]], None], |
|||
) -> None: |
|||
try: |
|||
from .qtmultimedia import QrReaderCameraDialog, CameraError, MissingQrDetectionLib |
|||
except ImportError as e: |
|||
icon = QMessageBox.Warning |
|||
title = _("QR Reader Error") |
|||
message = _("QR reader failed to load. This may happen if " |
|||
"you are using an older version of PyQt5.") + "\n\n" + str(e) |
|||
if isinstance(parent, MessageBoxMixin): |
|||
parent.msg_box(title=title, text=message, icon=icon, parent=None) |
|||
else: |
|||
custom_message_box(title=title, text=message, icon=icon, parent=parent) |
|||
return |
|||
|
|||
global _qr_dialog |
|||
if _qr_dialog: |
|||
_logger.warning("QR dialog is already presented, ignoring.") |
|||
return |
|||
_qr_dialog = None |
|||
try: |
|||
_qr_dialog = QrReaderCameraDialog(parent=parent, config=config) |
|||
|
|||
def _on_qr_reader_finished(success: bool, error: str, data): |
|||
global _qr_dialog |
|||
if _qr_dialog: |
|||
_qr_dialog.deleteLater() |
|||
_qr_dialog = None |
|||
callback(success, error, data) |
|||
|
|||
_qr_dialog.qr_finished.connect(_on_qr_reader_finished) |
|||
_qr_dialog.start_scan(config.get_video_device()) |
|||
except (MissingQrDetectionLib, CameraError) as e: |
|||
_qr_dialog = None |
|||
callback(False, str(e), None) |
|||
except Exception as e: |
|||
_logger.exception('camera error') |
|||
_qr_dialog = None |
|||
callback(False, repr(e), None) |
|||
|
|||
@ -0,0 +1,39 @@ |
|||
#!/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 Mapping |
|||
|
|||
from .camera_dialog import (QrReaderCameraDialog, CameraError, NoCamerasFound, |
|||
NoCameraResolutionsFound, MissingQrDetectionLib) |
|||
from .validator import (QrReaderValidatorResult, AbstractQrReaderValidator, |
|||
QrReaderValidatorCounting, QrReaderValidatorColorizing, |
|||
QrReaderValidatorStrong, QrReaderValidatorCounted) |
|||
|
|||
|
|||
def find_system_cameras() -> Mapping[str, str]: |
|||
"""Returns a camera_description -> camera_path map.""" |
|||
from PyQt5.QtMultimedia import QCameraInfo |
|||
system_cameras = QCameraInfo.availableCameras() |
|||
return {cam.description(): cam.deviceName() for cam in system_cameras} |
|||
@ -0,0 +1,463 @@ |
|||
#!/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 electrum.gui.qt.util import MessageBoxMixin, FixedAspectRatioLayout, ImageGraphicsEffect |
|||
|
|||
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 |
|||
|
|||
|
|||
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,63 @@ |
|||
#!/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. |
|||
# |
|||
# A module, that, given an image (buffer), finds and decodes a QR code in it. |
|||
|
|||
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