barcode/QmlBarcode

import os, sys
 
import cvb
import cvb.ui
 
from result_model import ResultModel
from barcode_reader import BarcodeReader
 
if sys.version_info >= (3, 11):
    from PySide6.QtCore import QObject, QUrl, QAbstractListModel, QModelIndex
    from PySide6.QtQml import QQmlApplicationEngine
    from PySide6.QtGui import QGuiApplication, QIcon
else:
    from PySide2.QtCore import QObject, QUrl, QAbstractListModel, QModelIndex
    from PySide2.QtQml import QQmlApplicationEngine
    from PySide2.QtGui import QGuiApplication, QIcon
 
 
if __name__ == "__main__":
 
    app = QGuiApplication([])
    app.setOrganizationName('STEMMER IMAGING')
    app.setOrganizationDomain('https://www.stemmer-imaging.com/')
    app.setApplicationName('Barcode Python tutorial')
 
    # tell Windows the correct AppUserModelID for this process (shows icon in the taskbar)
    if sys.platform == 'win32':
        import ctypes
        myappid = u'stemmerimaging.commonvisionblox.pybarcode.0'
        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 
    app.setWindowIcon(QIcon('Tutorial-Python_32x32.png'))
 
    # load the device
    device = cvb.DeviceFactory.open(
        os.path.join(cvb.install_path(), "drivers", "CVMock.vin"),
        cvb.AcquisitionStack.Vin)
    s = device.stream()
    # setup QML interface objects
    image_controller = cvb.ui.ImageController()
    result_model = ResultModel(image_controller)
    # result_model.Text = "abcd"
    # result_model.DecodeTime = 3000
    result_model.Location = [cvb.Point2D(1,2), cvb.Point2D(2,1)]
 
    # main classification object
    barcode_reader = BarcodeReader(device, result_model)
 
    # register QML components for an image display
    cvb.ui.ImageViewItem.register()
    cvb.ui.ImageLabelItem.register()
 
    engine = QQmlApplicationEngine()
    context = engine.rootContext()
 
    # create a controller object to communicate with QML
    context.setContextProperty("mainImage", image_controller)
    # create a Minos result model to communicate with QML for overlays
    context.setContextProperty("resultModel", result_model)
    # create a Minos search object to communicate with QML (grab, snap)
    context.setContextProperty("barcodeReader", barcode_reader)
 
    # load main QML file
    engine.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), "main.qml"))
    
    barcode_reader.snap_n_decode()
 
    app.exec_()

import os, sys
 
import cvb
import cvb.barcode
 
if sys.version_info >= (3, 11):
    from PySide6 import QtCore
    from PySide6.QtCore import QObject, Slot
else:
    from PySide2 import QtCore
    from PySide2.QtCore import QObject, Slot
 
from result_model import ResultModel
 
class BarcodeReader(QtCore.QObject):
    def __init__(self, device, result_model):
        super().__init__()
        self._device = device
        self._stream = device.stream()
        self._model = result_model
        self._barcode_config = cvb.barcode.ReaderConfig(cvb.barcode.ReaderInitialization.ReadAll)
    
    @Slot()
    def snap_n_decode(self):
        self.snap()
        self.decode()
 
    def snap(self):
        image, wait_status = self._stream.get_timed_snapshot(1000)
        if (wait_status != cvb.WaitStatus.Ok):
            return None
        self._model.refresh(image)
 
    def decode(self):
        result = cvb.barcode.decode(self._barcode_config, self._model.Image.planes[0], self._model.Image.bounds, cvb.barcode.ReadResultDataMatrix)
        if result.type == cvb.barcode.Symbology.DataMatrix :
            result.__class__ = cvb.barcode.ReadResultDataMatrix
        self._model.update(result)
    

 
import cvb
import cvb.ui
import sys
 
if sys.version_info >= (3, 11):
    from PySide6.QtCore import QObject, QAbstractListModel, Qt, QModelIndex, Property, Signal, Slot
else:
    from PySide2.QtCore import QObject, QAbstractListModel, Qt, QModelIndex, Property, Signal, Slot
 
    
 
class ResultModel(QAbstractListModel):
 
 
    _Text = ""
    _DecodeTime = 0
    _Location = [None] *0
    _location_role = Qt.UserRole
 
    def __init__(self, image_controller, parent=None):
        super(ResultModel, self).__init__(parent)
        self._image_controller = image_controller
 
 
    def roleNames(self):
        roles = dict()
        roles[ResultModel._location_role] = b"location"
        return roles
 
    def data(self, index, role = Qt.DisplayRole):
        if not index.isValid():
            return None
        pos = self._Location[index.row()]
        if role == ResultModel._location_role:
            return cvb.ui.cvb_to_qt_point(pos)
        else:
            return None
 
    def rowCount(self, parent = QModelIndex()):
        return len(self._Location)
 
    def update(self, barcode_result):
        self._result = barcode_result
        self._Text = barcode_result.text
        self._DecodeTime = barcode_result.decode_time
        self._Location = barcode_result.location
 
        self.layoutChanged.emit()
        self.notify_text.emit()
        self.notify_decode_time.emit()
        
    @Slot()
    def refresh(self, image):
        self.Image = image
        self._image_controller.refresh(image)
 
    def Text(self):
        return self._Text
 
    def DecodeTime(self):
        return self._DecodeTime
        
    notify_text = Signal()
    notify_decode_time = Signal()
 
    Text = Property(str, Text, notify=notify_text)
    DecodeTime = Property(int, DecodeTime, notify=notify_decode_time)
 
 
     

import QtQuick 2.3
import CvbQuick 1.0 as CvbQuick
import QtQuick.Controls 1.3
import QtQuick.Layouts 1.2
import QtQuick.Dialogs 1.2
 
ApplicationWindow
{
    id: rootWin
    visible: true
    property int margin: 11
    width: 1080
    height: 720
 
    RowLayout
    {
        id: mainLayout
        anchors.fill: parent
        anchors.margins: margin
        
        ColumnLayout
        {
            CvbQuick.ImageView
            {
                id: view
                image: mainImage
                Layout.fillWidth: true
                Layout.fillHeight: true
 
                Repeater
                {
                    model : resultModel
                    delegate: CvbQuick.ImageLabel
                    {
                        id: pointLabel
                        imageView : view
                        imageX : location.x
                        imageY : location.y
 
                        Rectangle 
                        {
                            width: 15
                            height: width
                            color: "red"
                            border.color: "black"
                            border.width: 1
                            radius: width*0.5
                        }          
                    }
                }
            }
            
            Button
            {
                text: "Snap"
                onClicked: barcodeReader.snap_n_decode()
            }
        }
 
        ColumnLayout
        {
            TextArea  
            {
                Layout.minimumWidth: parent.width * 0.3
                text: resultModel.Text
                readOnly: true
                wrapMode: Text.Wrap
                selectByMouse: true
            }
            Text       
            {
                text: "Processing time: " + resultModel.DecodeTime + " ms"
            }
 
        }
 
    }
 
 
}