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 *

from PIL import Image

import DTI_PID_UI

import QtImageViewer

from SingletonInstance import SingletonInstane

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

import CreateCommand

import CropCommand

import AreaOcrCommand

import CreateSymbolCommand

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

import QGraphicsPolylineItem

from QEngineeringLineItem import QEngineeringLineItem

from SymbolSvgItem import SymbolSvgItem

from QGraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from QEngineeringTextItem import QEngineeringTextItem

from QEngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringNoteItem import QEngineeringNoteItem

from QEngineeringSizeTextItem import QEngineeringSizeTextItem

from AppDocData import AppDocData

import QDirTreeWidget, QPropertyTableWidget

import QSymbolEditorDialog

import QResultTreeWidget

import QResultPropertyTableWidget

from TextItemFactory import TextItemFactory

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 MainWindow(QMainWindow, DTI_PID_UI.Ui_MainWindow, SingletonInstane):

    '''

        @brief      initialize

        @author 

        @date   

        @history    humkyung 2018.04.12 add splitter widget

                    Jeongwoo 2018.04.27 Add Signal/Slot Connection 'noteNoSingleClicked'

    '''

    def __init__(self):

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

        self.setupUi(self)

        project = AppDocData.instance().getCurrentProject()

        _translate = QCoreApplication.translate

        self.setWindowTitle(_translate("Digital P&ID - {}".format(project.name), "Digital P&ID - {}".format(project.name)))

        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.graphicsView.useDefaultCommand() ##### USE DEFAULT COMMAND

        self.verticalLayout.addWidget(self.graphicsView)

        # Add Custom TreeWidget

        self.dirTreeWidget = QDirTreeWidget.QDirTreeWidget()

        self.dirTreeWidget.header().hide()

        self.symbolTabVerticalLayout.addWidget(self.dirTreeWidget)

        # Add Custom Property TableWidget

        self.propertyTableWidget = QPropertyTableWidget.QPropertyTableWidget()

        self.symbolTabVerticalLayout.addWidget(self.propertyTableWidget)

        self.dirTreeWidget.singleClicked.connect(self.propertyTableWidget.getClickedSymbol)

        # add splitter widget

        splitter = QSplitter(Qt.Vertical)

        splitter.addWidget(self.dirTreeWidget)

        splitter.addWidget(self.propertyTableWidget)

        self.symbolTabVerticalLayout.addWidget(splitter)

        # up to here

        # Add Custom Result Tree Widget (Symbol Explorer)

        self.resultTreeWidget = QResultTreeWidget.QResultTreeWidget(self.graphicsView)

        self.resultTreeWidget.header().hide()

        self.symbolExplorerVerticalLayout.addWidget(self.resultTreeWidget)

        # Add Empty Widget

        self.resultPropertyTableWidget = QResultPropertyTableWidget.QResultPropertyTableWidget()

        self.symbolExplorerVerticalLayout.addWidget(self.resultPropertyTableWidget)

        self.resultTreeWidget.singleClicked.connect(self.resultPropertyTableWidget.getClickedSymbol)

        self.resultTreeWidget.noteNoSingleClicked.connect(self.resultPropertyTableWidget.getClickedNote)

        # add splitter widget

        splitter = QSplitter(Qt.Vertical)

        splitter.addWidget(self.resultTreeWidget)

        splitter.addWidget(self.resultPropertyTableWidget)

        self.symbolExplorerVerticalLayout.addWidget(splitter)

        # up to here

        # 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.actionLineRecognition.triggered.connect(self.recognizeLine)

        self.actionArea.triggered.connect(self.areaConfiguration)

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

        self.actionOCR.triggered.connect(self.areaOcr)

        self.actionGenerateOutput.triggered.connect(self.generateOutput)

        self.pushButtonCreateSymbol.clicked.connect(self.createSymbol)

        self.actionEquipment.triggered.connect(self.createEquipment)

        self.actionNozzle.triggered.connect(self.createNozzle)

        self.graphicsView.scene.changed.connect(lambda: self.resultTreeWidget.sceneChanged(self.graphicsView.scene.items()))

    '''

        @brief      Create Equipment

        @author     Jeongwoo

        @date       18.05.03

    '''

    def createEquipment(self):

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        if self.actionEquipment.isChecked():

            self.graphicsView.command = CreateSymbolCommand.CreateSymbolCommand(self.graphicsView, self.resultTreeWidget)

        else:

            self.graphicsView.useDefaultCommand()

    '''

        @brief      Create Nozzle

        @author     Jeongwoo

        @date       18.05.03

    '''

    def createNozzle(self):

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        if self.actionNozzle.isChecked():

            self.graphicsView.command = CreateSymbolCommand.CreateSymbolCommand(self.graphicsView, self.resultTreeWidget)

        else:

            self.graphicsView.useDefaultCommand()

    '''

        @brief      Area OCR

        @author     Jeongwoo

        @date       18.04.18

        @history    2018.05.02  Jeongwoo    Change graphicsView.command by actionOCR checked state

                                            Show MessageBox when imageviewer doesn't have image

    '''

    def areaOcr(self):

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        if self.actionOCR.isChecked():

            self.graphicsView.command = AreaOcrCommand.AreaOcrCommand(self.graphicsView)

        else:

            self.graphicsView.useDefaultCommand()

    '''

        @brief  area configuration

    '''

    def areaConfiguration(self):

        from QAreaConfigurationDialog import QAreaConfigurationDialog

        self.dlgAreaConfiguration = QAreaConfigurationDialog(self)

        self.dlgAreaConfiguration.show()

        self.dlgAreaConfiguration.exec_()

    '''

        @brief  configuration

    '''

    def configuration(self):

        from QConfigurationDialog import QConfigurationDialog

        self.dlgConfiguration = QConfigurationDialog(self)

        self.dlgConfiguration.show()

        self.dlgConfiguration.exec_()

    '''

        @brief  Show Image Selection Guide MessageBox

        @author Jeongwoo

        @date   2018.05.02

    '''

    def showImageSelectionMessageBox(self):

        QMessageBox.about(self.graphicsView, "알림", "이미지를 선택하신 후 시도해주세요.")

    '''

        @brief  Open image drawing file and then display it

        @author humkyung

        @date   2018.??.??

        @history    18.04.23    Jeongwoo    Add AppDocData.instance().setCurrentPidSource

                    18.04.23    Jeongwoo    Add Store Set Current Pid Image on AppDocData

                    18.05.02    Jeongwoo    Add useDefaultCommand()

    '''

    def openImageDrawing(self, MainWindow):

        import random

        try:

            self.graphicsView.clearImage()

            self.graphicsView.scene.clear()

            self.graphicsView.useDefaultCommand()

            self.path = self.graphicsView.loadImageFromFile()

            if os.path.isfile(self.path):

                baseName = os.path.basename(self.path)

                AppDocData.instance().setCurrentPidSource(Image.open(self.path))

                self.resultTreeWidget.setCurrentPID(baseName)

                # DEBUG

                '''

                if __debug__:

                    from LineDetector import LineDetector

                    from LineNoTracer import LineNoTracer

                    self.loadRecognitionResult('d:/Projects/DTIPID/DTI_PID/DTI_PID/SG_TEST/output/UY1-K-2005G_P1_300dpi_black.xml')

                    # detect line

                    connectedLines = []

                    img = cv2.cvtColor(cv2.imread(self.path), cv2.COLOR_BGR2GRAY)

                    detector = LineDetector(img)

                    symbols = []

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

                        if type(item) is SymbolSvgItem:

                            symbols.append(item)

                            color = QColor(random.randrange(0,255), random.randrange(0,255), random.randrange(0,255))

                            res = detector.detectConnectedLine(item, 0, 0)

                            if res is not None:

                                for line in res: connectedLines.append(line)

                    texts = []

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

                        if (type(item) is QEngineeringTextItem): texts.append(item)

                    if len(connectedLines) > 1:

                        detector.mergeLines(connectedLines, toler=20)

                        # connect line to symbol

                        try:

                            for line in connectedLines:

                                matches = [symbol for symbol in symbols if symbol.isConnectable(line, (0,0), toler=40)]

                                for symbol in matches:

                                    detector.connectLineToSymbol(line, (0,0), symbol)

                        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))

                        # up to here

                        # connect line to line

                        try:

                            for line in connectedLines[:]:

                                matches = [it for it in connectedLines if (line != it) and (not detector.isParallel(line, it))]

                                for match in matches:

                                    detector.connectLineToLine(match, line)

                        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))

                        # up to here

                    lines = []

                    for pts in connectedLines:

                        processLine = QEngineeringLineItem()

                        lines.append(processLine)

                        for pt in pts:

                            processLine._pol.append(QPointF(pt[0], pt[1]))

                        processLine._path.addPolygon(processLine._pol)

                        processLine.setPath(processLine._path)

                        processLine.setPen(QPen(color, 5, Qt.SolidLine))

                        self.graphicsView.scene.addItem(processLine)

                    detector.saveImage()

                    # trace line no

                    tracer = LineNoTracer(symbols, lines, texts)

                    tracer.execute()

                    # up to here

                    # construct line no item

                    docData = AppDocData.instance()

                    for text in docData.lineNos:

                        item = self.resultTreeWidget.addTreeItem(self.resultTreeWidget.root, text)

                        if 1 == len(text.conns):

                            # iterate connected items

                            pool = []

                            visited = []

                            pool.append(text.conns[0])

                            while len(pool) > 0:

                                it = pool.pop()

                                if type(it) is SymbolSvgItem: self.resultTreeWidget.addTreeItem(item, it)

                                visited.append(it)

                                for conn in it.conns:

                                    if (conn is not None) and (conn not in visited): pool.append(conn)

                            # up to here

                    # up to here

                # 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))

        return self.path

    '''

        @brief  create a symbol

        @history    2018.05.02  Jeongwoo    Change return value of QSymbolEditorDialog (Single variable → Tuple)

                                            Add SymbolSvgItem

                    2018.05.03  Jeongwoo    Change method to draw Svg Item on Scene (svg.addSvgItemToScene)

                                            Change method to make svg and image path

    '''

    def createSymbol(self):

        image = self.graphicsView.image()

        if image is not None:

            symbolEditorDialog = QSymbolEditorDialog.QSymbolEditorDialog(self, image, AppDocData.instance().getCurrentProject())

            (isAccepted, isImmediateInsert, offsetX, offsetY, newSym) = symbolEditorDialog.showDialog()

            self.dirTreeWidget.initDirTreeWidget()

            if isAccepted:

                if isImmediateInsert:

                    svgPath = newSym.getSvgFileFullPath()

                    img = cv2.imread(newSym.getImageFileFullPath(), 1)

                    w, h = (0, 0)

                    if len(img.shape[::-1]) == 2:

                        w, h = img.shape[::-1]

                    else:

                        _chan, w, h = img.shape[::-1]

                    svg = SymbolSvgItem(svgPath)

                    svg.buildItem(newSym.getName(), newSym.getType(), 0, [offsetX, offsetY], [w, h], [float(x) for x in newSym.getOriginalPoint().split(',')], [(float(x.split(',')[0]), float(x.split(',')[1])) for x in newSym.getConnectionPoint().split('/')])

                    #### lambda param=svg : bind 'svg' object to lambda('param')

                    #### If case of 'lambda svg=svg:', function uses the 'svg' value bound to lambda

                    svg.clicked.connect(lambda param=svg: self.resultTreeWidget.findItem(param))

                    svg.removed.connect(self.resultTreeWidget.itemRemoved)

                    svg.addSvgItemToScene(self.graphicsView.scene)

                    for connector in svg.connectors:

                        self.graphicsView.scene.addItem(connector)

    #'''

    #    @brief  connect equipment and nozzle

    #'''

    #def connectEqpNozzle(self):

    #    self.graphicsView.command = None

    '''

        @brief  create a line

        @author humkyung

    '''

    def createLine(self):

        # set imageviewer's command

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

        # up to here

    '''

        @brief      recognize symbol and text

        @author     humkyung

        @date       2018.04.??

        @history    2018.04.16  humkyung    execute line no tracing

                    2018.05.02  Jeongwoo    Show MessageBox when imageviewer doesn't have image

    '''

    def recognize(self, MainWindow):

        from QRecognitionDialog import QRecognitionDialog

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        try:

            self.dlg = QRecognitionDialog(self)

            self.startThread()

            self.dlg.show()

            self.dlg.exec_()

            if self.dlg.isAccepted == True:

                self.loadRecognitionResult(self.xmlPath[0])

        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  remove small objects from given image

        @author humkyung

        @date   2018.04.26

    '''

    def removeSmallObjects(self, image):

        try:

            docData = AppDocData.instance()

            configs = docData.getConfigs('Small Object Size', 'Min Area')

            minArea = int(configs[0].value) if 1 == len(configs) else 20

            configs = docData.getConfigs('Small Object Size', 'Max Area')

            maxArea = int(configs[0].value) if 1 == len(configs) else 50

            #path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), 'before_contours.png')

            #cv2.imwrite(path, image)

            _,contours,_ = cv2.findContours(image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE);

            selectedContours=[]

            for contour in contours:

                #if cv2.isContourConvex(contour):

                    #approx = cv2.approxPolyDP(contour, 0.2*cv2.arcLength(contour, True), True)

                area = cv2.contourArea(contour)

                if area > minArea and area < maxArea: selectedContours.append(contour)

            contourImage = cv2.drawContours(image, selectedContours, -1, (255,255,255), -1);

            #path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), 'contours.png')

            #cv2.imwrite(path, contourImage)

        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))

        return contourImage

    '''

        @brief      recognize line

        @author     humkyung

        @date       2018.04.19

        @history    2018.04.26 Jeongwoo Variable name changed (texts → lineNos)

                                        TextItem type changed (QEngineeringTextItem → QEngineeringLineNoTextItem)

        @history    2018.04.26 humkyung remove small objects before recognizing line

                    2018.05.02 Jeongwoo Show MessageBox when imageviewer doesn't have image

    '''

    def recognizeLine(self, MainWindow):

        from LineDetector import LineDetector

        from LineNoTracer import LineNoTracer

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        try:

            #remove already existing line item

            items = [item for item in self.graphicsView.scene.items() if type(item) is QEngineeringLineItem]

            for item in items:

                self.graphicsView.scene.removeItem(item)

            #up to here

            # detect line

            connectedLines = []

            area = AppDocData.instance().getArea('Drawing')

            area.img = self.removeSmallObjects(area.img)

            detector = LineDetector(area.img)

            symbols = []

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

                if issubclass(type(item), SymbolSvgItem):

                    symbols.append(item)

                    res = detector.detectConnectedLine(item, round(area.x), round(area.y))

                    if res is not None:

                        for line in res: connectedLines.append(line)

            texts = [item for item in self.graphicsView.scene.items() if issubclass(type(item), QEngineeringTextItem)]

            for symbol in symbols:

                symbol.connectAttribute(texts)

            lineNos = [item for item in self.graphicsView.scene.items() if type(item) is QEngineeringLineNoTextItem]

            if len(connectedLines) > 1:

                detector.mergeLines(connectedLines, toler=20)

                # connect line to symbol

                try:

                    for line in connectedLines:

                        matches = [symbol for symbol in symbols if symbol.isConnectable(line, (round(area.x), round(area.y)), toler=20)]

                        for symbol in matches:

                            detector.connectLineToSymbol(line, (round(area.x), round(area.y)), symbol)

                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))

                # up to here

                # connect line to line

                try:

                    for line in connectedLines[:]:

                        matches = [it for it in connectedLines if (line != it) and (not detector.isParallel(line, it))]

                        for match in matches:

                            detector.connectLineToLine(match, line)

                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))

                # up to here

            lines = []

            for pts in connectedLines:

                processLine = QEngineeringLineItem()

                lines.append(processLine)

                for pt in pts:

                    processLine._pol.append(QPointF(pt[0] + round(area.x), pt[1] + round(area.y)))

                processLine.buildItem()

                processLine.setPen(QPen(Qt.blue, 5, Qt.SolidLine))

                self.graphicsView.scene.addItem(processLine)

            # trace line no

            tracer = LineNoTracer(symbols, lines, lineNos)

            tracer.execute()

            # up to here

            # construct line no item

            docData = AppDocData.instance()

            for text in docData.lineNos:

                item = self.resultTreeWidget.addTreeItem(self.resultTreeWidget.root, text)

                connectedItems = text.getConnectedItems()

                for connectedItem in connectedItems:

                    if issubclass(type(connectedItem), SymbolSvgItem): self.resultTreeWidget.addTreeItem(item, connectedItem)

            # 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

        @author     humkyung

        @date       2018.04.??

        @history    humkyung 2018.01.12 parse originalpoint and connectionpoint

                    Jeongwoo 2018.04.17 add QGraphicItem with Rotated text

                    Jeongwoo 2018.04.23 Change to Draw texts on QEngineeringTextItem

                    humkyung 2018.04.23 connect item remove slot to result tree

                    Jeongwoo 2018.04.25 Add if state with QEngineeringNoteItem

                    Jeongwoo 2018.04.26 Change method to create TextItem object with TextItemFactory

                    Jeongwoo 2018.05.03 Change method to draw Svg Item on Scene (svg.addSvgItemToScene)

    '''

    def loadRecognitionResult(self, xmlPath):

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

        try:

            project = AppDocData.instance().getCurrentProject()

            xml = parse(xmlPath)

            root = xml.getroot();

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

                pt = [float(x) for x in symbol.find('STARTPOINT').text.split(',')]

                size = [float(x) for x in symbol.find('SIZE').text.split(',')]

                name = symbol.find('NAME').text

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

                type = symbol.find('TYPE').text

                origin = [float(x) for x in symbol.find('ORIGINALPOINT').text.split(',')]

                connPts = []

                if symbol.find('CONNECTIONPOINT').text is not None:

                    connPts = [(float(x.split(',')[0]), float(x.split(',')[1])) for x in symbol.find('CONNECTIONPOINT').text.split('/')]

                svgFilePath = os.path.join(project.getSvgFilePath(), type, name + '.svg')

                if os.path.isfile(svgFilePath):

                    svg = SymbolSvgItem.createItem(type, svgFilePath)

                    svg.buildItem(name, type, angle, pt, size, origin, connPts)

                    #### lambda param=svg : bind 'svg' object to lambda('param')

                    #### If case of 'lambda svg=svg:', function uses the 'svg' value bound to lambda

                    svg.clicked.connect(lambda param=svg: self.resultTreeWidget.findItem(param))

                    svg.removed.connect(self.resultTreeWidget.itemRemoved)

                    svg.addSvgItemToScene(self.graphicsView.scene)

                    for connector in svg.connectors:

                        self.graphicsView.scene.addItem(connector)

                else:

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

                    item.isSymbol = True

                    item.angle = angle

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

                    self.graphicsView.scene.addItem(item)

            docData = AppDocData.instance()

            configs = docData.getConfigs('Line No', 'Delimiter')

            delimiter = configs[0].value if 1 == len(configs) else '-'

            lineNoconfigs = docData.getConfigs('Line No', 'Configuration')

            # parse texts

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

                x = float(text.find('X').text) if text.find('X') is not None else 0

                y = float(text.find('Y').text) if text.find('Y') is not None else 0

                width = float(text.find('WIDTH').text) if text.find('WIDTH') is not None else 0

                height = float(text.find('HEIGHT').text) if text.find('HEIGHT') is not None else 0

                angle = float(text.find('ANGLE').text) if text.find('ANGLE') is not None else 0

                text = text.find('TEXT').text

                item = TextItemFactory.instance().createTextItem(text, delimiter, lineNoconfigs)

                if item is not None:

                    item.loc = (x, y)

                    item.size = (width, height)

                    item.angle = angle

                    item.setPlainText(text)

                    item.setDefaultTextColor(Qt.blue)

                    item.removed.connect(self.resultTreeWidget.itemRemoved)

                    item.addTextItemToScene(self.graphicsView.scene)

            # parse notes

            for note in root.iter('NOTE'):

                x = float(note.find('X').text) if note.find('X') is not None else 0

                y = float(note.find('Y').text) if note.find('Y') is not None else 0

                width = float(note.find('WIDTH').text) if note.find('WIDTH') is not None else 0

                height = float(note.find('HEIGHT').text) if note.find('HEIGHT') is not None else 0

                angle = float(note.find('ANGLE').text) if note.find('ANGLE') is not None else 0

                text = note.find('TEXT').text

                item = TextItemFactory.instance().createTextItem(text)

                item.loc = (x, y)

                item.size = (width, height)

                item.angle = angle

                item.setPlainText(text)

                item.setDefaultTextColor(Qt.blue)

                item.addTextItemToScene(self.graphicsView.scene)

                #self.graphicsView.scene.addItem(item)

            # 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  generate output xml file

        @author humkyung

        @date   2018.04.23

        @history    2018.05.02  Jeongwoo    Show MessageBox when imageviewer doesn't have image

    '''

    def generateOutput(self):

        import XmlGenerator as xg

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        try:

            docData = AppDocData.instance()

            # TODO: how to check equipment

            docData.equipments.clear()

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

                if (type(item) is SymbolSvgItem) and item.type == 'Specialty Components':

                    docData.equipments.append(item)

            # up to here

            xg.writeOutputXml(docData.imgName, docData.imgWidth, docData.imgHeight)

        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  start thread

        @author humkyung

        @date   2018.04.??

    '''

    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

    from App import App 

    app = App(sys.argv)

    try:

        dlg = Ui_Dialog()

        selectedProject = dlg.showDialog()

        if selectedProject is not None:

            AppDocData.instance().setCurrentProject(selectedProject)

            app.mainWnd = MainWindow.instance()

            app.mainWnd.show()

    except Exception as ex:

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

    sys.exit(app.exec_())