HYTOS

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

            conn = self.project.database.connect()

            with conn:

                matches = [favorite for favorite in self.favorites if symbol.getUid() == favorite[1]]

                    '''

                    layout_item = self.layout.takeAt(matches[0])

                    self.layout.removeWidget(item)

                    item.deleteLater()

                    del item

                    self.layout.removeItem(layout_item)

                    del layout_item

                    '''

        self.pushButtonBatchRecognition.clicked.connect(self.recognizeBatch)

            self.pushButtonBatchRecognition.setVisible(False)

                for childIdex in range(drawingList.childCount()):

                    drawingList.child(childIdex).setCheckState(0, Qt.Unchecked)

                for childIdex in range(drawingList.childCount()):

                    child = drawingList.child(childIdex)

                    if child.text(0).replace('.png', '') == app_doc_data.activeDrawing.name:

                        break

    def recognizeBatch(self, MainWindow):

        '''

            @brief      batch recognize symbol, text and line

            @author     euisung

            @date       2018.11.23

        '''

        project = app_doc_data.getCurrentProject()

        app_doc_data.needReOpening = None

        # TODO: 무슨 의미인지 주석 필요

        drawingTop = self.treeWidgetDrawingList.topLevelItem(0)

        drawingCount = drawingTop.childCount()

        checkedTreeItems = []

        checkedDrawingPath = []

        for drawing in range(drawingCount):

            drawingChild = drawingTop.child(drawing)

            if drawingChild.checkState(0) == 2:

                checkedTreeItems.append(drawingChild)

                checkedDrawingPath.append(os.path.join(project.getDrawingFilePath(), drawingChild.data(0, 0)))

                if currentPid is not None and drawingChild.data(0, 0).find(currentPid) is 0:

                    app_doc_data.needReOpening = False  # later check need reopening at drawUnknownItems()

                    currentPid = drawingChild.data(0, 0)

        if len(checkedDrawingPath) == 0:

            self.dlg = QRecognitionDialog(self, checkedDrawingPath, True)

            self.dlg.exec_()

            if self.dlg.isAccepted == True:

                pass

            if app_doc_data.needReOpening == True:

            drawings = app_doc_data.getDrawings()

            checkedDrawings = []

            for checkedTreeItem in checkedTreeItems:

                for drawing in drawings:

                    if checkedTreeItem.data(0, 0) == drawing.name:

                        if drawing:

                            drawing.datetime = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

                            checkedDrawings.append(drawing)

                            checkedTreeItem.setText(1, datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

            app_doc_data.saveDrawings(checkedDrawings)

        @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

                    2018.05.25  Jeongwoo    Add parameter on QRecognitionDialog.__init__() and Move thread to QRecognitionDialog

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

                    2018.05.29  Jeongwoo    Remove connects and comments

                    humkyung 2018.11.05 save working date-time

    '''

    def recognize(self, MainWindow):

        from datetime import datetime

        from RecognitionDialog import QRecognitionDialog

        if not self.graphicsView.hasImage():

            self.showImageSelectionMessageBox()

            return

        # save alarm

        self.save_alarm_enable(False)

        try:

            appDocData = AppDocData.instance()

            self.onClearLog()

            appDocData.needReOpening = False

            drawingList = []

            drawingList.append(self.path)

            self.dlg = QRecognitionDialog(self, drawingList, False)

            self.dlg.exec_()

            if appDocData.needReOpening:

                self.itemTreeWidget.setCurrentPID(appDocData.activeDrawing.name)

                self.drawDetectedItemsToScene()

                # save working date-time

                drawings = appDocData.getDrawings()

                drawing = [drawing for drawing in drawings if appDocData.imgName == os.path.splitext(drawing.name)[0]]

                if drawing[0]:

                    drawing[0].datetime = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

                    appDocData.saveDrawings(drawing)

                currentPid = appDocData.activeDrawing.name

                drawingTop = self.treeWidgetDrawingList.topLevelItem(0)

                drawingCount = drawingTop.childCount()

                for drawing in range(drawingCount):

                    drawingChild = drawingTop.child(drawing)

                    if drawingChild.data(0, 0).find(currentPid) is 0:

                        drawingChild.setText(1, datetime.now().strftime('%Y-%m-%d %H:%M:%S'))

                self.changeViewCheckedState(True)

                # up to here

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

        finally:

            # save alarm

            self.save_alarm_enable(True)

    '''

    '''

        @brief      recognize line

        @author     humkyung

        @date       2018.04.19

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

                                        TextItem type changed (QEngineeringTextItem → QEngineeringLineNoTextItem)

                    humkyung 2018.04.26 remove small objects before recognizing line

                    Jeongwoo 2018.05.02 Show MessageBox when imageviewer doesn't have image

                    Jeongwoo 2018.05.25 Move codes about LineDetector

                    humkyung 2018.06.17 show progress dialog

    '''

    '''

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

                                            SvgItem and TextItem Connect with method in this class

                                            Change method to add GraphicsItem

                    2018.05.28  Jeongwoo    Make QGraphicsItem by symbol, text object. Not xml

                    2018.05.29  Jeongwoo    Change method name and Moved from QRecognitionDialog

                    2018.05.30  Jeongwoo    Add parameters on SymbolSvgItem.__init__() (parentSymbol, childSymbol)

                                            Change Method name and seperate each item

                    humkyung 2018.06.11     display difference between original and recognized image

                    Jeongwoo 2018.06.18     Update Scene after all item added

                    2018.11.05  euisung     add save note item because of dependency

                    2018.11.05  euisung     add db delete process before save

                    2018.11.12  euisung     add title block properties

                    2018.11.12  euisung     db part move new method to dbUpdate

                    2018.11.26  euisung     isolate scene adding part -> drawDetectedItemsToScene()

                    2018.11.29  euisung     change name drawDetectedItems() -> createDetectedItems

    '''

    def createDetectedItems(self, symbolList, textInfoList, otherTextInfoList, titleBlockTextInfoList):

        try:

            QApplication.processEvents()

            self.createDetectedSymbolItem(symbolList)

            QApplication.processEvents()

            self.createDetectedTextItem(textInfoList)

            QApplication.processEvents()

            self.createDetectedOtherTextItem(otherTextInfoList)

            QApplication.processEvents()

            self.createDetectedTitleBlockTextItem(titleBlockTextInfoList)

            # update scene

            # self.graphicsView.scene().update(self.graphicsView.sceneRect())

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    def drawDetectedItemsToScene(self):

        """add detected items to scene"""

        from SaveWorkCommand import SaveWorkCommand

        app_doc_data = AppDocData.instance()

        try:

            for symbol in app_doc_data.symbols:

                if issubclass(type(symbol), SymbolSvgItem):

                    symbol.addSvgItemToScene(self.graphicsView.scene())

                else:

                    self.graphicsView.scene().addItem(symbol)

            for text in app_doc_data.texts:

                self.addTextItemToScene(text)

            for lineNo in app_doc_data.tracerLineNos:

                self.addTextItemToScene(lineNo)

            # remove lines which is located inside symbol

            for symbol in app_doc_data.symbols:

                rect = symbol.sceneBoundingRect()

                rect.adjust(-10, -10, 10, 10)

                matches = [line for line in app_doc_data.lines if rect.contains(line.line().p1()) and

                           rect.contains(line.line().p2()) and

                           not line.has_connection]

                app_doc_data.lines = [line for line in app_doc_data.lines if line not in matches]

            # up to here

            for line in app_doc_data.lines:

                self.graphicsView.scene().addItem(line)

                line.transfer.onRemoved.connect(self.itemRemoved)

                for conn in line.connectors:

                    conn.transfer.onPosChanged.connect(line.onConnectorPosChaned)

            for unknown in app_doc_data.unknowns + app_doc_data.lineIndicators:

                self.graphicsView.scene().addItem(unknown)

            # save scene

            self.dbUpdate()

            SaveWorkCommand.save_to_xml()

        finally:

            # update scene

            self.graphicsView.scene().update(self.graphicsView.sceneRect())

    def createDetectedTitleBlockTextItem(self, textInfoList):

        '''

            @brief  draw title block

            @author euisung

            @date   2018.11.12

            @history    2018.11.26  euisung     remove scene dependency

                        2018.11.29  euisung     change name drawDetectedTitleBlockTextItem() -> createDetectedTitleBlockTextItem

        '''

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse texts

            for textInfos in textInfoList:

                if len(textInfos[1]) is 0:

                    continue

                for textInfo in textInfos[1]:

                    x = textInfo.getX()

                    y = textInfo.getY()

                    width = textInfo.getW()

                    height = textInfo.getH()

                    angle = round(math.radians(textInfo.getAngle()), 2)

                    text = textInfo.getText()

                    if not text: continue

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

                    if item is not None:

                        item.loc = [x, y]

                        item.size = (width, height)

                        item.angle = angle

                        item.area = textInfos[0]

                        # self.addTextItemToScene(item)

                        # appDocData.texts.append(item)

                        appDocData.allItems.append(item)

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    '''

        @brief      

        @author     humkyung

        @date       2018.08.23

        @history    2018.11.26  euisung     remove scene dependency

                    2018.11.26  euisung     isolate scene adding part -> drawDetectedItemsToScene()

                    2018.11.    euisung     no more used

                    2018.11.29  euisung     change name drawDetectedLines() -> createDetectedLines

    '''

    def createDetectedLines(self, lineList, worker):

        appDocData = AppDocData.instance()

        area = appDocData.getArea('Drawing')

        for pts in lineList:

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

            processLine.area = 'Drawing'

            # self.graphicsView.scene().addItem(processLine)

            appDocData.lines.append(processLine)

            appDocData.allItems.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

    '''

        history     2018.06.09  humkyung    check length of original and connection point is 2 while parsing

                    2018.11.26  euisung     remove scene dependency

                    2018.11.29  euisung     change name drawDetectedSymbolItem() -> createDetectedSymbolItem

    '''

    def createDetectedSymbolItem(self, symbolList):

        from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

        from SymbolSvgItem import SymbolSvgItem

        import math

        try:

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            searchedMap = []

            for symbol in symbolList:

                pt = [float(x) for x in symbol.getSp()]

                size = [symbol.getWidth(), symbol.getHeight()]

                name = symbol.getName()

                angle = round(math.radians(symbol.getRotatedAngle()), 2)

                _type = symbol.getType()

                flip = symbol.getDetectFlip()

                origin = [0, 0]

                if 2 == len(symbol.getOriginalPoint().split(',')):

                    tokens = symbol.getOriginalPoint().split(',')

                    origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                connPts = []

                if symbol.getConnectionPoint() is not None and symbol.getConnectionPoint() != '':

                    for param in symbol.getConnectionPoint().split('/'):

                        tokens = param.split(',')

                        connPts.append(

                            ('AUTO', pt[0] + float(tokens[0]), pt[1] + float(tokens[1]), '0') if len(tokens) == 2 else \

                                (tokens[0], pt[0] + float(tokens[1]), pt[1] + float(tokens[2]), '0') if len(

                                    tokens) == 3 else \

                                    (tokens[0], pt[0] + float(tokens[1]), pt[1] + float(tokens[2]), tokens[3]) if len(

                                        tokens) == 4 else None)

                parentSymbol = symbol.getBaseSymbol()

                childSymbol = symbol.getAdditionalSymbol()

                hasInstrumentLabel = symbol.getHasInstrumentLabel()

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

                if os.path.isfile(svgFilePath):

                    svg = SymbolSvgItem.createItem(_type, None, svgFilePath, owner=None, flip=flip)

                    svg.hit_ratio = symbol.hitRate

                    svg.buildItem(name, _type, angle, pt, size, origin, connPts, parentSymbol, childSymbol,

                                  hasInstrumentLabel)

                    # svg.reCalculationRotatedItem()

                    svg.area = 'Drawing'

                    # set owner - 2018.07.20 added by humkyung                   

                    matches = [searched for searched in searchedMap if searched[0] == symbol.owner]

                    if len(matches) == 1:

                        svg.owner = matches[0][1]

                    searchedMap.append((symbol, svg))

                    # up to here

                    svg.transfer.onRemoved.connect(self.itemRemoved)

                    # self.addSvgItemToScene(svg)

                    appDocData.symbols.append(svg)

                    appDocData.allItems.append(svg)

                else:

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

                    item.isSymbol = True

                    item.angle = angle

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

                    # self.graphicsView.scene().addItem(item)

                    # appDocData.symbols.append(item)

                    appDocData.allItems.append(item)

            # up to here

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    '''

        @history    2018.06.08  Jeongwoo    Add parameter on round method

        @history    2018.11.02  euisung     Add save note text item

        @history    2018.11.05  euisung     delete save note text item and move to drawDetectedItems()

                    2018.11.26  euisung     remove scene dependency

                    2018.11.29  euisung     change name drawDetectedTextItem() -> createDetectedTextItem

    '''

    def createDetectedTextItem(self, textInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse texts

            for textInfo in textInfoList:

                x = textInfo.getX()

                y = textInfo.getY()

                width = textInfo.getW()

                height = textInfo.getH()

                angle = round(math.radians(textInfo.getAngle()), 2)

                text = textInfo.getText()

                if not text: continue

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

                if item is not None:

                    item.loc = [x, y]

                    item.size = (width, height)

                    item.angle = angle

                    item.area = 'Drawing'

                    item.transfer.onRemoved.connect(self.itemRemoved)

                    # self.addTextItemToScene(item)

                    # appDocData.texts.append(item)

                    appDocData.allItems.append(item)

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    '''

        @brief      draw detected texts except which in drawing area

        @history    2018.11.29  euisung     change name drawDetectedOtherTextItem() -> createDetectedOtherTextItem

    '''

    def createDetectedOtherTextItem(self, otherTextInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

            appDocData = AppDocData.instance()

            # parse notes

            for textInfoMap in otherTextInfoList:

                if textInfoMap[0] == 'Note' or textInfoMap[1] is None:

                    pass

                for textInfo in textInfoMap[1]:

                    x = textInfo.getX()

                    y = textInfo.getY()

                    width = textInfo.getW()

                    height = textInfo.getH()

                    angle = round(math.radians(textInfo.getAngle()))

                    text = textInfo.getText()

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

                    item.loc = [x, y]

                    item.size = (width, height)

                    item.angle = angle

                    item.area = textInfoMap[0]

                    item.transfer.onRemoved.connect(self.itemRemoved)

                    # appDocData.texts.append(item)

                    appDocData.allItems.append(item)

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    '''

        @brief  draw unknown items 

        @author humkyung

        @date   2018.06.12

        @history    2018.06.14  Jeongwoo    Change method to add unknown item

                    2018.06.18  Jeongwoo    Add connect on unknown item

                                            Add [transfer] for using pyqtSignal

                    2018.11.26  euisung     remove scene dependency

                    2018.11.26  euisung     isolate scene adding part -> drawDetectedItemsToScene()

                    2018.11.27  euisung     add save to xml

                    2018.11.29  euisung     change name drawUnknownItems() -> createUnknownItems

    '''

    def createUnknownItems(self, path):

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringUnknownItem import QEngineeringUnknownItem

        try:

            docData = AppDocData.instance()

            project = docData.getCurrentProject()

            windowSize = docData.getSlidingWindowSize()

            thickness = int(windowSize[1] / 2)

            if docData.needReOpening is not None:

                docData.needReOpening = True

            diffFilePath = os.path.join(project.getTempPath(), "DIFF_" + os.path.basename(path))

            if os.path.isfile(diffFilePath):

                imgDiff = cv2.threshold(cv2.cvtColor(cv2.imread(diffFilePath, 1), cv2.COLOR_BGR2GRAY), 0, 255,

                                        cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]

                # remove line from image

                lines = docData.lines

                for line in lines:

                    line.drawToImage(imgDiff, 255, thickness) if line.thickness is None else \

                        line.drawToImage(imgDiff, 255, line.thickness)

                cv2.imwrite(diffFilePath, imgDiff)

                # up to here

                imgNot = np.ones(imgDiff.shape, np.uint8)

                cv2.bitwise_not(imgDiff, imgNot)

                configs = docData.getConfigs('Filter', 'ErodeSize')

                kernel = int(configs[0].value) if 1 == len(configs) else 3

                imgNot = cv2.erode(imgNot, np.ones((kernel, kernel), np.uint8))

                imgNot = cv2.dilate(imgNot, np.ones((8 + kernel, 8 + kernel), np.uint8))

                contours, hierarchy = cv2.findContours(imgNot, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

                ##

                idx = 0

                ##

                smallContours = []

                minimumSize = docData.getConfigs('Filter', 'MinimumSize')

                for contour in contours:

                    [x, y, w, h] = cv2.boundingRect(contour)

                    # remove too small one

                    if len(minimumSize) is 1:

                        if (w * h < int(minimumSize[0].value) * int(minimumSize[0].value)):

                            smallContours.append(contour)

                            idx += 1

                            continue

                    '''

                    rect = QRectF(x, y, w, h)

                    items = [item for item in diffItems if item.boundingRect().contains(rect)]

                    if len(items) > 0: continue

                    items = [item for item in diffItems if rect.contains(item.boundingRect())]

                    for item in items:

                        diffItems.remove(item)

                    '''

                    # create unknown item

                    epsilon = cv2.arcLength(contour, True) * 0.001

                    approx = cv2.approxPolyDP(contour, epsilon, True)

                    approx = [pt[0] for pt in approx]

                    resultStr, resultList = self.determineRemainObject(idx, contours, imgNot)

                    if resultStr == 'LineIndicator':

                        item = QEngineeringUnknownItem(approx, 'True', resultList[0], resultList[1])

                        docData.lineIndicators.append(item)

                    elif resultStr == 'MissingLine':

                        pass

                    elif resultStr == 'Unknown':

                        item = QEngineeringUnknownItem(approx, 'False')

                        docData.unknowns.append(item)

                    item.area = 'Drawing'

                    docData.allItems.append(item)

                    item.transfer.onRemoved.connect(self.itemRemoved)

                    idx += 1

                    # up to here                    

                imgNotRemoveSmall = cv2.drawContours(imgNot, smallContours, -1, 0, -1)

                notFilePath = os.path.join(project.getTempPath(), "NOT_" + os.path.basename(path))

                cv2.imwrite(notFilePath, imgNotRemoveSmall)

            else:

                message = 'can\'t found {}'.format(diffFilePath)

                self.addMessage.emit(MessageType.Normal, message)

        except Exception as ex:

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

                                                           sys.exc_info()[-1].tb_lineno)

            self.addMessage.emit(MessageType.Error, message)

    def determineRemainObject(self, idx, contours, imgNot):

        '''

            @brief      determine remain objects -> line no indicator or unknown

            @author     euisung

            @date       2018.12.26

            @history    2019.03.25  euisung    Change name isLineNoIndicator -> determineRemainObject

        '''

        import math

        [x, y, w, h] = cv2.boundingRect(contours[idx])

        if (w < 250 and h < 250):

            return ('Unknown', [])

        fLines = []

        maxDifAngle = 3

        mask = np.zeros_like(imgNot)

        cv2.drawContours(mask, contours, idx, 123, -1)  # Draw filled contour in mask

        out = np.zeros_like(imgNot)  # Extract out the object and place into output image

        out[mask == 123] = imgNot[mask == 123]

        # Now crop

        ##print(out)

        (x, y) = np.where(mask == 123)

        (topx, topy) = (np.min(x), np.min(y))

        (bottomx, bottomy) = (np.max(x), np.max(y))

        out = out[topx:bottomx + 1, topy:bottomy + 1]

        h, w = out.shape[0], out.shape[1]

        maxDifH, maxDifW = math.ceil(math.tan(4 * math.pi / 180) / 2 * w), math.ceil(

            math.tan(4 * math.pi / 180) / 2 * h)

        # detection lines

        edged2 = cv2.Canny(out, 100, 200)

        lines = cv2.HoughLinesP(image=edged2, rho=1, theta=np.pi / 180, threshold=25, minLineLength=30, maxLineGap=25)

        # lines = cv2.HoughLines(edged2, 1, np.pi/180, 60)

        if lines is None:

            return ('Unknown', [])

        for line in lines:

            # r, theta = line[0]

            # a, b = np.cos(theta), np.sin(theta)

            # x0, y0 = a * r, b * r

            # x1, y1 = int(x0 + 1000 * (-b)), int(y0 + 1000 * a)

            # x2, y2 = int(x0 - 1000 * (-b)), int(y0 - 1000 * a)

            # cv2.line(out, (x1, y1), (x2, y2), (0, 255, 0), 3)

            x1, y1, x2, y2 = line[0]

            degree = math.atan2(y2 - y1, x2 - x1) * 180 / math.pi

            fLine = [x1, y1, x2, y2, degree]

            # print(fLine)

            fLines.append(fLine)

        horLines = []

        verLines = []

        otherLines = []

        isVH = None

        for fLine in fLines:

            degree = math.fabs(fLine[4])

            if degree >= 90 - maxDifAngle:

                verLines.append(fLine)

            elif degree <= maxDifAngle:

                horLines.append(fLine)

            else:

                otherLines.append(fLine)

        baseLines = []

        baseDifV = 0

        if len(horLines):

            x, y = w / 2, 0

            baseDifV = maxDifH

            for horLine in horLines:

                x1, y1, x2, y2 = horLine[0], horLine[1], horLine[2], horLine[3]

                y = ((y2 - y1) / (x2 - x1)) * x + y1 - ((y2 - y1) / (x2 - x1)) * x1

                horLine.append(y)

            baseLines = horLines

            isVH = 'H'

        if len(verLines):

            x, y = 0, h / 2

            baseDifV = maxDifW

            for verLine in verLines:

                x1, y1, x2, y2 = verLine[0], verLine[1], verLine[2], verLine[3]

                x = ((x2 - x1) / (y2 - y1)) * y + x1 - ((x2 - x1) / (y2 - y1)) * y1

                verLine.append(x)

            baseLines = verLines

            isVH = 'V'

        for otherLine in otherLines:

            x, y = w / 2, 0

            x1, y1, x2, y2 = otherLine[0], otherLine[1], otherLine[2], otherLine[3]

            y = ((y2 - y1) / (x2 - x1)) * x + y1 - ((y2 - y1) / (x2 - x1)) * x1

            otherLine.append(y)

        # determine line no indicator 

        if not ((len(horLines) > 0 and len(verLines) > 0) or len(otherLines) is 0 or (

                len(horLines) == 0 and len(verLines) == 0)):

            result, mergedOtherLine = self.isLineNoIndicator(w, h, maxDifAngle, baseDifV, baseLines, otherLines)

            if result:

                # print(fLines)

                return ('LineIndicator', [isVH, mergedOtherLine])

        return ('Unknown', [])

    def isLineNoIndicator(self, w, h, maxDifAngle, baseDifV, baseLines, otherLines):

        '''

            @brief      determine line no indicator

            @author     euisung

            @date       2019.03.25

        '''

        import math

        if (w < 250 and h < 250):

            return (False, None)

        isSameLine = True

        i = 0

        for baseLine in baseLines:

            if not isSameLine: break

            j = 0

            for baseLinee in baseLines:

                if i == j:

                    j += 1

                    continue

                difV = math.fabs(baseLine[5] - baseLinee[5])

                if difV > baseDifV:

                    isSameLine = False

                    break

                j += 1

            i += 1

        if not isSameLine:

            return (False, None)

        isSameLine = True

        i = 0

        maxY = 0

        for otherLine in otherLines:

            y = otherLine[5]

            if math.fabs(y) > maxY:

                maxY = math.fabs(y)

            if not isSameLine: break

            j = 0

            for otherLinee in otherLines:

                if i == j:

                    j += 1

                    continue

                difV = math.fabs(otherLine[4] - otherLinee[4])

                if difV > maxDifAngle:

                    isSameLine = False

                    break

                j += 1

            i += 1

        if not isSameLine:

            return (False, None)

        isSameLine = True

        mergedOtherLine = [0, 0, 0, 0]

        i = 0

        maxDif = math.ceil(math.tan(4 * math.pi / 180) * maxY)

        for otherLine in otherLines:

            if not isSameLine: break

            j = 0

            for otherLinee in otherLines:

                if i == j:

                    j += 1

                    continue

                angle = math.fabs(otherLine[4] + otherLinee[4]) / 2

                difV = math.fabs(otherLine[5] - otherLinee[5])

                dist = math.sin((90 - angle) * math.pi / 180) * difV

                if dist > maxDif:

                    isSameLine = False

                    break

                j += 1

            i += 1

            mergedOtherLine[0] += otherLine[0]

            mergedOtherLine[1] += otherLine[1]

            mergedOtherLine[2] += otherLine[2]

            mergedOtherLine[3] += otherLine[3]

        if not isSameLine:

            (False, None)

        # Show the output image

        # print('line no indicator')

        mergedOtherLine[0] = round(mergedOtherLine[0] / len(otherLines))

        mergedOtherLine[1] = round(mergedOtherLine[1] / len(otherLines))

        mergedOtherLine[2] = round(mergedOtherLine[2] / len(otherLines))

        mergedOtherLine[3] = round(mergedOtherLine[3] / len(otherLines))

        # cv2.line(out, (mergedOtherLine[0], mergedOtherLine[1]), (mergedOtherLine[2], mergedOtherLine[3]), (255, 255, 255), 3)

        # cv2.imshow('Output', out)

        # cv2.waitKey(0)

        # cv2.destroyAllWindows()

        return (True, mergedOtherLine)

                    self.addTextItemToScene(item)

                    self.addTextItemToScene(item)

                    self.addTextItemToScene(item)

                    self.addTextItemToScene(item)

                self.addTextItemToScene(line_no)

        @date       2018.05.25

        @history    2018.05.29  Jeongwoo    Moved from QRecognitionDialog

                    2018.06.05  Jeongwoo    Remove Size condition

                    2018.06.18  Jeongwoo    Set Z-index

    '''

    def addTextItemToScene(self, textItem):

        textItem.addTextItemToScene(self.graphicsView.scene())

    '''

        @brief      Remove added item on same place and Add GraphicsItem

        @author     Jeongwoo

# Form implementation generated from reading ui file './UI/MainWindow.ui'

# Created by: PyQt5 UI code generator 5.11.3

        self.pushButtonBatchRecognition = QtWidgets.QPushButton(self.tabDrawingList)

        self.pushButtonBatchRecognition.setMaximumSize(QtCore.QSize(80, 16777215))

        self.pushButtonBatchRecognition.setObjectName("pushButtonBatchRecognition")

        self.horizontalLayout_4.addWidget(self.pushButtonBatchRecognition)

        self.tabWidgetItemExplorer.setCurrentIndex(0)

        self.pushButtonBatchRecognition.setText(_translate("MainWindow", "Batch Job"))

if __name__ == "__main__":

    import sys

    app = QtWidgets.QApplication(sys.argv)

    MainWindow = QtWidgets.QMainWindow()

    ui = Ui_MainWindow()

    ui.setupUi(MainWindow)

    MainWindow.show()

    sys.exit(app.exec_())

                Worker.executeRecognition(self.createDetectedItems, self.path, self.listWidget, self.isLineChecked,

                                          self, self.batch, self.createUnknownItems)