polimago/QmlCookieClassification

import os, sys

import cvb
import cvb.ui
from result_model import ResultModel
from classification import Classification

from PySide2.QtCore import QObject, QUrl, QAbstractListModel, Qt, QModelIndex
from PySide2.QtQml import QQmlApplicationEngine, qmlRegisterType
from PySide2.QtGui import QGuiApplication, QIcon


if __name__ == "__main__":

    app = QGuiApplication([])
    app.setOrganizationName('STEMMER IMAGING')
    app.setOrganizationDomain('https://www.stemmer-imaging.com/')
    app.setApplicationName('Polimago 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.pycookieclassification.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)
        
    # setup QML interface objects
    image_controller = cvb.ui.ImageController()
    result_model = ResultModel(image_controller)

    # main classification object
    classification = Classification(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("classification", classification)

    # load main QML file
    engine.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), "main.qml"))

    # do a first snap at startup
    classification.snap()

    app.exec_()

import os, sys

import cvb
import cvb.polimago

from PySide2 import QtCore
from PySide2.QtCore import QObject, Qt, QUrl, Property, Signal, Slot

from result_model import ResultModel, PolimagoResult


# Global params
GRID_STEP = 0.6
THRESHOLD = 0.0
LOCALITY = 1.0


class Classification(QtCore.QObject):

    def __init__(self, device, result_model):
        super().__init__()
        self._device = device
        self._stream = device.stream()
        self._model = result_model
        self._search = cvb.polimago.SearchPredictor(os.path.join(cvb.install_path(), "tutorial", "Polimago", "Images", "Cookies", "Cookies.psc"))
        self._classification = cvb.polimago.ClassificationPredictor(os.path.join(cvb.install_path(), "tutorial", "Polimago", "Images", "Cookies", "CookieType.pcc"))

        self._source = ""
        self._search_predictor = ""
        self._classification_predictor = ""

        self.notify_source.connect(self.source_changed)
        self.notify_search_predictor.connect(self.search_predictor_changed)
        self.notify_classification_predictor.connect(self.classification_predictor_changed)

    @Slot()
    def snap(self):
        # clear the result
        self._model.update([None] * 0)
        self._image, wait_status = self._stream.get_timed_snapshot(1000)
        if (wait_status != cvb.WaitStatus.Ok):
            return None
        # refresh image view
        self._model.refresh(self._image)

    @Slot()
    def classify(self):

        if self._search == 0 or self._classification == 0:
            sys.stderr.write('No search predictor or classification predictor was loaded.\n')
            return None

        # 1. find items
        search_res, calls = self._search.grid_search(self._image, self._image.bounds, GRID_STEP, THRESHOLD, LOCALITY)

        polimago_results = [None] * 0

        for res in search_res:
            # only use results with quality >= 0.3
            if res.quality >= 0.3:
                # 2. classify the items
                pos = cvb.Point2D(res.x, res.y)
                clf_res, confidence_distribution = self._classification.classify(self._image, pos)
                polimago_results.append(PolimagoResult(pos, res.quality, clf_res))

        # 3. show result
        self._model.update(polimago_results)

    def source(self):
        return self._source

    def set_source(self, imageSource):
        self._source = imageSource
        self.notify_source.emit()

    def search_predictor(self):
        return self._search_predictor

    def set_search_predictor(self, searchPredictor):
        self._search_predictor = searchPredictor
        self.notify_search_predictor.emit()

    def classification_predictor(self):
        return self._classification_predictor

    def set_classification_predictor(self, classificationPredictor):
        self._classification_predictor = classificationPredictor
        self.notify_classification_predictor.emit()

    @Signal
    def notify_source(self):
        pass

    @Signal
    def notify_search_predictor(self):
        pass

    @Signal
    def notify_classification_predictor(self):
        pass

    @Slot()
    def source_changed(self):
        # clear the result
        self._model.update([])
        # clear predictors
        self._search = 0
        self._classification = 0
        # close current device
        self._device.close()
        # open new device / image
        path = self._source.toLocalFile()
        if path.endswith(".vin"):
            self._device = cvb.DeviceFactory.open(
                path, cvb.AcquisitionStack.Vin)
            self._stream = self._device.stream()
            self.snap()
        elif path.endswith(".bmp"):
            self._image = cvb.Image(path)
            self._model.refresh(self._image)

    @Slot()
    def search_predictor_changed(self):
        if not self.search_predictor().isEmpty():
            self._search = cvb.polimago.SearchPredictor(self.search_predictor().toLocalFile())

    @Slot()
    def classification_predictor_changed(self):
        if not self.classification_predictor().isEmpty():
            self._classification = cvb.polimago.ClassificationPredictor(self.classification_predictor().toLocalFile())

    imageSource = Property(QUrl, source, set_source)
    searchPredictor = Property(QUrl, search_predictor, set_search_predictor)
    classificationPredictor = Property(QUrl, classification_predictor, set_classification_predictor)

import os

import cvb
import cvb.ui

from PySide2.QtCore import QObject, QAbstractListModel, Qt, QModelIndex, Property, Signal, Slot

class PolimagoResult(object):
    
    def __init__(self, pos, pos_quality, clf_res):
        self._pos = pos
        self._pos_quality = pos_quality
        self._name = clf_res.name
        self._color_quality = clf_res.quality

    def position(self):
        return self._pos

    def name(self):
        return self._name

    def position_quality(self):
        return self._pos_quality

    def color_quality(self):
        return self._color_quality

class ResultModel(QAbstractListModel):

    LineText = Qt.UserRole
    StartPosition = Qt.UserRole + 1
    Quality = Qt.UserRole + 2

    def __init__(self, image_controller, parent=None):
        super(ResultModel, self).__init__(parent)
        self._image_controller = image_controller
        self._results = [None] * 0

    def update(self, polimago_results):
        self._results = polimago_results
        self.layoutChanged.emit()

    def roleNames(self):
        roles = dict()
        roles[ResultModel.LineText] = b"lineText"
        roles[ResultModel.StartPosition] = b"startPosition"
        roles[ResultModel.Quality] = b"quality"
        return roles

    def rowCount(self, parent = QModelIndex()):
        return len(self._results)

    def data(self, index, role = Qt.DisplayRole):
        if not index.isValid():
            return None

        result = self._results[index.row()]

        if role == ResultModel.LineText:
            return result.name()
        elif role == ResultModel.StartPosition:
            return cvb.ui.cvb_to_qt_point(result.position())
        elif role == ResultModel.Quality:
            return result.position_quality()
        else:
            return None

    @Slot()
    def refresh(self, image):
        self._image_controller.refresh(image)

        

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

    ColumnLayout
    {
        id: mainLayout
        anchors.fill: parent
        anchors.margins: margin

        CvbQuick.ImageView
        {
            id: view
            image: mainImage
            Layout.fillWidth: true
            Layout.fillHeight: true

            Repeater
            {
                model : resultModel
                delegate: TextLabel
                {
                    imageView : view
                    imageX : startPosition.x
                    imageY : startPosition.y
                    posQuality : quality
                    text : lineText

                }
            }
        }

        RowLayout
        {
          Button
          {
            text: "Load Image"
            onClicked: openImageDialog.open()
          }

          Button
          {
            text: "Load Search Predictor"
            onClicked: loadSearchPredictorDialog.open()
          }

          Button
          {
            text: "Load Classification Predictor"
            onClicked: loadClassificationPredictorDialog.open()
          }

          Button
          {
            id: btnSnap
            text: "Snap"
            onClicked: classification.snap()
          }

          Button
          {
            text: "Classify"
            onClicked: classification.classify()
          }


        }

        FileDialog
       {
         id: openImageDialog
         title: "Open Image"
         selectExisting: true
          nameFilters: [ "Image source files (*.bmp)", "Common Vision Blox driver files (*.vin)" ]
          onAccepted:
          {
            classification.imageSource = openImageDialog.fileUrl;
            var path = classification.imageSource.toString();
            if (path.endsWith(".bmp"))
              btnSnap.enabled = false
            else
              btnSnap.enabled = true
          }
        }

        FileDialog
       {
         id: loadSearchPredictorDialog
         title: "Load Search Predictor"
         selectExisting: true
          nameFilters: [ "Search classifier (*.psc)" ]
          onAccepted: classification.searchPredictor = loadSearchPredictorDialog.fileUrl;
        }

        FileDialog
       {
         id: loadClassificationPredictorDialog
         title: "Load Classification Predictor"
         selectExisting: true
          nameFilters: [ "Classification predictor (*.pcc)" ]
          onAccepted: classification.classificationPredictor = loadClassificationPredictorDialog.fileUrl;
        }
    }
}

import QtQuick 2.3
import CvbQuick 1.0 as CvbQuick

// Output result as overlay
CvbQuick.ImageLabel
{
  id: label
  property var text : ""
  property var posQuality : 0.0 

  Text
  {
    text: label.text + " (Q=" + String(label.posQuality.toFixed(2)) + ")"
    font.pointSize : 10
    font.bold: true
    color : "white"
    style: Text.Outline
    styleColor: "black"  
  }
}