HYTOS

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

                App.mainWin().addMessage(MessageType.Error, message)

                return (pt, -1)

            norm = [-dir[1], dir[0]]

        appDocData = AppDocData.instance()

        appDocData.deleteDataListBeforeSave()

        titleBlockProps = appDocData.getTitleBlockProperties()

        #items = self.graphicsView.scene.items()

        items = appDocData.allItems

        titleBlockItems = []

        for item in items:

            if type(item) is QEngineeringLineNoTextItem:

                item.saveLineData()

            elif type(item) is QEngineeringTextItem:

                for titleBlockProp in titleBlockProps:

                    if item.area == titleBlockProp[0]:

                        titleBlockItems.append(item)

        dbItems = [item for item in items if type(item) is QEngineeringInstrumentItem or type(item) is QEngineeringEquipmentItem or\

        type(item) is QEngineeringNoteItem or type(item) is SymbolSvgItem] + titleBlockItems

        appDocData.saveToDatabase(dbItems)

    #drawDetectedItems = pyqtSignal(list, list, list, list, QObject)

    #drawDetectedLines = pyqtSignal(list, QObject)

    #drawUnknownItems = pyqtSignal(str, QObject)

                        '''

                        _pt = searchedSymbolList[i].getSp()

                        rect = QRectF(_pt[0], _pt[1], searchedSymbolList[i].getWidth(), searchedSymbolList[i].getHeight())

                        _rect = QRectF(searchedItemSp[0], searchedItemSp[1], sw, sh)

                        if rect.intersects(_rect):

                            intersect = rect.intersected(_rect)

                            overlapArea = intersect.width()*intersect.height()

                            if overlapArea > sw*sh*0.1:

                                break

                        '''

                        overlapArea = Worker.contains(searchedSymbolList[i], searchedItemSp, sw, sh)

                        if overlapArea > ACCEPT_OVERLAY_AREA:

                                    ## DEBUG

                                    ##message = '//// {}:{}-{} ////'.format(symbolName, searchedItemSp, hitRate)

                                    ##worker.displayLog.emit(MessageType.Normal, message)

                                    ## up to here

                                ## DEBUG

                                message = '{}->{}:{}-{}'.format(searchedSymbol.getName(), symbolName, searchedItemSp, hitRate)

                                worker.displayLog.emit(MessageType.Normal, message)

                                ## up to here

                                threadLock.acquire()

                                foundSymbolCount = foundSymbolCount + 1

                                Worker.addSearchedSymbol(symbolName, symbolType , 

                                    searchedItemSp, sw, sh, symbolThreshold, hitRate, hitRate, symbolRotatedAngle , 

                                    isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild , 

                                    originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                                threadLock.release()

            loop.quit()  

    '''

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

                    2018.05.28  Jeongwoo    Add xmlPath Parameter and append LineInfo into xml

                    2018.05.29  Jeongwoo    Change method to add item

                    2018.05.30  Jeongwoo    Remove parameter (xmlPath)

                    humkyung 2018.06.11 add drawing path to parameter and write recognized lines to image

                    humkyung 2018.07.04 call arrangeLinePosition after creating line

    '''

    '''

    def recognizeLine(self, path, listWidget, graphicsView, worker):

        from shapely.geometry import Point, LineString

        from SymbolSvgItem import SymbolSvgItem

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringTextItem import QEngineeringTextItem

        from EngineeringLineItem import QEngineeringLineItem

        from LineDetector import LineDetector

        try:

            listWidget.addItem('Starting line recognization')

            #remove already existing line and flow arrow item

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

            for item in items:

                worker.graphicsView.scene.removeItem(item)

            #up to here

            # detect line

            connectedLines = []

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

            area.img = worker.removeSmallObjects(area.img)

            detector = LineDetector(area.img)

            symbols = []

            for item in worker.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:

                        connectedLines.extend(res)

            listWidget.addItem('Connecting lines')

            if len(connectedLines) > 1:

                detector.mergeLines(connectedLines, toler=5)

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

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

                    MainWindow.instance().displayMessage.emit(MessageType.Error, message)

                # up to here

                # connect line to line

                toler = 10

                try:

                    for line in connectedLines:

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

                        # get closest line

                        selected = []

                        shapelyLine = LineString(line)

                        for match in matches:

                            dist = [shapelyLine.distance(Point(match[0][0], match[0][1])),shapelyLine.distance(Point(match[1][0], match[1][1]))]

                            if dist[0] < toler or dist[1] < toler:

                                selected.append(match)

                        # up to here

                        for match in selected:

                            detector.connectLineToLine(match, line, toler)

                except Exception as ex:

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

                    workder.displayLog.emit(MessageType.Error, message)

                # up to here

            for pts in connectedLines:

                processLine = QEngineeringLineItem(vertices=[(area.x + param[0], area.y + param[1]) for param in pts])

                graphicsView.scene.addItem(processLine)

                #lines.append(processLine)

                if processLine.length() > 100: # TODO: check critical length

                    processLine.addFlowArrow()

            # re-order process line's start,end according to flow mark

            worker.arrangeLinePosition(lines, symbols, listWidget)

            # up to here

        except Exception as ex:

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

            worker.displayLog.emit(MessageType.Error, message)

        finally:

            listWidget.addItem('Finished line recognization')

            worker.finished.emit()

    '''