HYTOS

    listWidget.addItem('Finish Symbol   : ' + os.path.basename(symbolPath.replace('.png', '')) + ' - (' + str(foundSymbolCount) + ')')

            #start = timeit.default_timer()

            #stop = timeit.default_timer()    

            #seconds = stop - start

            #listWidget.addItem("\nRunning Time : " + str(seconds / 60) + "min\n")

                                            Remove codes below if self.dlg.isAccepted == True

            self.dlg = QRecognitionDialog(self.graphicsView, self.path)

            self.dlg.svgItemClicked.connect(self.svgItemClicked)

            self.dlg.itemRemoved.connect(self.itemRemoved)

                '''DO NOTHING'''

                #if self.dlg.xmlPath is not None:

                #    self.loadRecognitionResult(self.dlg.xmlPath[0])

        @brief

        @date       2018.05.25

        @author     Jeongwoo

    def svgItemClicked(self, svgItem):

        self.resultTreeWidget.findItem(svgItem)

    '''

        @brief

        @date       2018.05.25

        @author     Jeongwoo

    '''

    def itemRemoved(self, item):

        self.resultTreeWidget.itemRemoved(item)

                    Jeongwoo 2018.05.25 Move codes about LineDetector

            lines = []

            lineNos = []

                elif type(item) is QEngineeringLineNoTextItem:

                    lineNos.append(item)

                elif type(item) is QEngineeringLineItem:

                    lines.append(item)

import sys

import os

import cv2

from AppDocData import AppDocData

from LineDetector import LineDetector

from QEngineeringLineItem import QEngineeringLineItem

from QEngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

from SymbolSvgItem import SymbolSvgItem

from QEngineeringTextItem import QEngineeringTextItem

'''

    @history    2018.05.25  Jeongwoo    Add pyqtSignal(recognizeLine, loadRecognitionResult)

'''

    import timeit

    recognizeLine = pyqtSignal()

    loadRecognitionResult = pyqtSignal(str)

    '''

        @history    2018.05.25  Jeongwoo    Add if-statements by isSymbolTextChecked and isLineChecked variable

    '''

        import timeit

            start = timeit.default_timer()

                if self.xmlPath is not None and len(self.xmlPath) > 0:

                    self.loadRecognitionResult.emit(self.xmlPath[0])

            if isLineChecked:

                self.recognizeLine.emit()

        finally:

            stop = timeit.default_timer()    

            seconds = stop - start

            self.listWidget.addItem("\nRunning Time : " + str(seconds / 60) + "min\n")

'''

    @history    2018.05.25  Jeongwoo    Add pyqtSignal(svgItemClicked, itemRemoved)

'''

    svgItemClicked = pyqtSignal(SymbolSvgItem)

    itemRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, graphicsView, path):

        QDialog.__init__(self, graphicsView)

        self.graphicsView = graphicsView

        self.obj.recognizeLine.connect(self.recognizeLine)

        self.obj.loadRecognitionResult.connect(self.loadRecognitionResult)

        self.ui.buttonBox.setEnabled(True)

    '''

        @brief  remove small objects from given image

        @author humkyung

        @date   2018.04.26

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

    '''

    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

    '''

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

                                            SvgItem and TextItem Connect with method in this class

    '''

    def loadRecognitionResult(self, xmlPath):

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

        from TextItemFactory import TextItemFactory

        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.svgItemClickedEvent(param))

                    svg.removed.connect(lambda param=svg: self.itemRemovedEvent(param))

                    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.removed.connect(lambda param=item: self.itemRemovedEvent(param))

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

    '''

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

    '''

    def recognizeLine(self):

        try:

            #remove already existing line and flow arrow item

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

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

                self.graphicsView.scene.addItem(processLine)

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

        finally:

            self.ui.listWidget.addItem('Finish Line searching')

    '''

        @brief      Emit svgItem to slot on MainWindow

        @date       2018.05.25

        @author     Jeongwoo

    '''

    def svgItemClickedEvent(self, svgItem):

        self.svgItemClicked.emit(svgItem)

    '''

        @brief      Emit svgItem to slot on MainWindow

        @date       2018.05.25

        @author     Jeongwoo

    '''

    def itemRemovedEvent(self, item):

        self.itemRemoved.emit(item)

        #super(QEngineeringLineItem, self).__init__()

        QGraphicsPolylineItem.__init__(self, parent)

                    2018.05.25  Jeongwoo    Change self.pen's default color (red → blue)

            self.pen = QPen(Qt.blue, 4, Qt.SolidLine)   # default pen