HYTOS

# coding: utf-8

import sys

import os

import cv2

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from PyQt5.QtSvg import *

import DTI_PID_UI

import QtImageViewer

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Commands')

import CreateCommand

import CropCommand

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

import QGraphicsPolylineItem

from QEngineeringLineItem import QEngineeringLineItem

from SymbolSvg import SymbolSvg

from QGraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

class Worker(QObject):

    from PyQt5.QtCore import QThread

    from PyQt5.QtWidgets import QApplication, QLabel, QWidget, QGridLayout

    import sys

    from DTI_PID import executeRecognition

    finished = pyqtSignal()

    intReady = pyqtSignal(int)

    #pyqtSlot()

    def procCounter(self): # A slot takes no params

        from DTI_PID import executeRecognition

        try:

            self.xmlPath = executeRecognition(self.path, self.listWidget)

            self.finished.emit()

        except Exception as ex:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

class SingletonInstane:

    __instance = None

    @classmethod

    def __getInstance(cls):

        return cls.__instance

    @classmethod

    def instance(cls, *args, **kargs):

        cls.__instance = cls(*args, **kargs)

        cls.instance = cls.__getInstance

        return cls.__instance

class ExampleApp(QMainWindow, DTI_PID_UI.Ui_MainWindow, SingletonInstane):

    def __init__(self):

        super(self.__class__, self).__init__()

        self.setupUi(self)

        self.lineComboBox = QComboBox(self.toolBar)

        self.lineComboBox.addItem('Primary Line')

        self.lineComboBox.addItem('Secondary Line')

        self.lineComboBox.addItem('Utility Line')

        self.toolBar.insertWidget(self.actionValidate, self.lineComboBox)

        self.toolBar.insertSeparator(self.actionValidate)

        self.graphicsView = QtImageViewer.QtImageViewer()

        self.graphicsView.setParent(self.centralwidget)

        self.verticalLayout.addWidget(self.graphicsView)

        # connect signals and slots

        self.actionClose.triggered.connect(self.close)

        self.actionOpen.triggered.connect(self.openImageDrawing)

        self.actionEqpNozzle.triggered.connect(self.connectEqpNozzle)

        self.actionLine.triggered.connect(self.createLine)

        self.actionRecognition.triggered.connect(self.recognize)

        self.actionConfiguration.triggered.connect(self.configuration)

    '''

        @brief  configuration

    '''

    def configuration(self):

        from QConfigurationDialog import QConfigurationDialog

        self.dlgConfiguration = QConfigurationDialog(self)

        self.dlgConfiguration.show()

        self.dlgConfiguration.exec_()

    '''

        @brief Open image drawing file and then display it

    '''

    def openImageDrawing(self, MainWindow):

        self.path = self.graphicsView.loadImageFromFile()

        svg = SymbolSvg()

        svg.setPos(100,100) 

        self.graphicsView.scene.addItem(svg)

        # DEBUG

        '''

        from LineDetector import LineDetector

        self.loadRecognitionResult('d:\\Projects\\DTIPID\\DTI_PID\\DTI_PID\\res\\Result\\UY1-K-2007_P1_300dpi_black.xml')

        # detect line

        img = cv2.imread(self.path)

        detector = LineDetector(img)

        for item in self.graphicsView.scene.items():

            if type(item) is QGraphicsBoundingBoxItem:

                res = detector.Detect(item)

                for pts in res:

                    line = QEngineeringLineItem()

                    line._vertices.append(QPointF(pts[0][0], pts[0][1]))

                    line._vertices.append(QPointF(pts[1][0], pts[1][1]))

                    self.graphicsView.scene.addItem(line)

        detector.save()

        '''

        # up to here

        return self.path

    '''

        @brief  connect equipment and nozzle

    '''

    def connectEqpNozzle(self):

        self.graphicsView.command = None

    '''

        @brief  create a line

    '''

    def createLine(self):

        # set imageviewer's command

        self.graphicsView.command = CreateCommand.CreateCommand(self.graphicsView, QEngineeringLineItem())

        # up to here

    '''

        @brief recognize symbol and text

    '''

    def recognize(self, MainWindow):

        from QRecognitionDialog import QRecognitionDialog

        from LineDetector import LineDetector

        try:

            self.dlg = QRecognitionDialog(self)

            self.startThread()

            self.dlg.show()

            self.dlg.exec_()

            if self.dlg.isAccepted == True:

                self.loadRecognitionResult(self.xmlPath[0])

                # detect line

                img = cv2.imread(self.path)

                detector = LineDetector(img)

                for item in self.graphicsView.scene.items():

                    if (type(item) is QGraphicsBoundingBoxItem) and item.isSymbol:

                        res = detector.Detect(item)

                        for pts in res:

                            line = QEngineeringLineItem()

                            line._vertices.append(QPointF(pts[0][0], pts[0][1]))

                            line._vertices.append(QPointF(pts[1][0], pts[1][1]))

                            self.graphicsView.scene.addItem(line)

                # up to here

        except Exception as ex:

            print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))

    '''

        @brief load recognition result

    '''

    def loadRecognitionResult(self, xmlPath):

        from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse

        try:

            xml = parse(xmlPath)

            root = xml.getroot();

            for symbol in root.iter('SYMBOL'):

                pt = symbol.find('STARTPOINT').text.split(',')

                size = symbol.find('SIZE').text.split(',')

                item = QGraphicsBoundingBoxItem(float(pt[0]), float(pt[1]), float(size[0]), float(size[1]))

                item.isSymbol = True

                item.angle = float(symbol.find('ANGLE').text)

                item.setPen(QPen(Qt.red, 20, Qt.SolidLine))

                self.graphicsView.scene.addItem(item)

            '''

            for text in root.iter('TEXTINFO'):

                x = float(text.find('X').text)

                y = float(text.find('Y').text)

                width = float(text.find('WIDTH').text)

                height = float(text.find('HEIGHT').text)

                item = QGraphicsBoundingBoxItem(x, y, width, height)

                item.setPen(QPen(Qt.blue, 20, Qt.SolidLine))

                self.graphicsView.scene.addItem(item)

            '''

        except Exception as ex:

            print('error occured {} as at {0}'.format(ex, sys.exc_info()[-1].tb_lineno))

    '''

        @brief start thread

    '''

    def startThread(self):

        self.dlg.ui.buttonBox.setDisabled(True)

        # 1 - create Worker and Thread inside the Form

        self.obj = Worker()  # no parent!

        self.obj.path = self.path

        self.obj.listWidget = self.dlg.ui.listWidget

        self.thread = QThread()  # no parent!

        # 2 - Connect Worker`s Signals to Form method slots to post data.

        #self.obj.intReady.connect(self.onIntReady)

        # 3 - Move the Worker object to the Thread object

        self.obj.moveToThread(self.thread)

        # 4 - Connect Worker Signals to the Thread slots

        self.obj.finished.connect(self.thread.quit)

        # 5 - Connect Thread started signal to Worker operational slot method

        self.thread.started.connect(self.obj.procCounter)

        # * - Thread finished signal will close the app if you want!

        self.thread.finished.connect(self.dlgExit)

        # 6 - Start the thread

        self.thread.start()

    '''

        @brief set buttonbox's enabled flag

    '''

    def dlgExit(self):

        self.xmlPath = self.obj.xmlPath

        self.dlg.ui.buttonBox.setEnabled(True)

if __name__ == '__main__':

    import DTI_PID_UI

    from ProjectDialog import Ui_Dialog

    app = QApplication(sys.argv)

    try:

        dlg = Ui_Dialog()

        dlg.show()

        dlg.exec_()

        if dlg.selectedProject is not None:

            form = ExampleApp.instance()

            form.show()

    except Exception as ex:

        print('에러가 발생했습니다.\n', ex)

    sys.exit(app.exec_())

# coding: utf-8

import os

import sqlite3

from SingletonInstance import SingletonInstane

DB_NAME = os.path.dirname(os.path.realpath(__file__)) + "\\db\\DTI_PID.db"

class AppDocData(SingletonInstane):

    '''

        @brief  get sliding window size

    '''

    def getSlidingWindowSize(self):

        res = [10,10]

        try:

            # Creates or opens a file called mydb with a SQLite3 DB

            db = sqlite3.connect(DB_NAME)

            # Get a cursor object

            cursor = db.cursor()

            sql = "select * from configuration where section='Sliding Window'"

            cursor.execute(sql)

            rows = cursor.fetchall()

            for row in rows:

                if row[1] == 'Width':

                    res[0] = int(row[2])

                elif row[1] == 'Height':

                    res[1] = int(row[2])

        # Catch the exception

        except Exception as e:

            # Roll back any change if something goes wrong

            db.rollback()

            raise e

        finally:

            # Close the db connection

            db.close()

        return res

    pass

def executeRecognition(path, listWidget):

        from AppDocData import AppDocData

        windowSize = AppDocData.instance().getSlidingWindowSize()

# coding: utf-8

class SingletonInstane:

    __instance = None

    @classmethod

    def __getInstance(cls):

        return cls.__instance

    @classmethod

    def instance(cls, *args, **kargs):

        cls.__instance = cls(*args, **kargs)

        cls.instance = cls.__getInstance

        return cls.__instance