HYTOS

# coding: utf-8

"""

    This is recognition dialog module

"""

import sys

import os

import threading

import cv2

import numpy as np

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

import Recognition_UI

import concurrent.futures as futures

from AppDocData import *

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from QEngineeringOPCItem import QEngineeringOPCItem

from LineDetector import LineDetector

from symbol import Symbol

from MainWindow import MainWindow

# region Symbol Image path List for test

targetSymbolList = []

# endregion

# region Global variables

searchedSymbolList = []

textInfoList = []

src = []

ocrCompletedSrc = []

afterDenoising = []

canvas = []

#WHITE_LIST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

MIN_TEXT_SIZE = 10

THREAD_MAX_WORKER = os.cpu_count()

threadLock = threading.Lock()

ACCEPT_OVERLAY_AREA = 20

# endregion

'''

    @history    2018.05.25  Jeongwoo    Add pyqtSignal(recognizeLine, loadRecognitionResult)

'''

class Worker(QObject):

    from PyQt5.QtCore import QThread

    from PyQt5.QtCore import QTranslator

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

    from QtImageViewer import QtImageViewer

    import sys

    '''

        @history    2018.05.30  Jeongwoo    Remove parameter on recognizeLine signal / Change signal name (drawDetectedItems)

        @history    humkyung 2018.06.08 add signal for progressbar

        @history    euisung 2018.11.27 add signal for unknown items

    '''

    finished = pyqtSignal()

    intReady = pyqtSignal(int)

    displayTitle = pyqtSignal(str)

    displayMessage = pyqtSignal(QListWidgetItem)

    updateProgress = pyqtSignal(int, str)

    updateBatchProgress = pyqtSignal(int, int)

    displayLog = pyqtSignal(MessageType, str)

    add_detected_items_to_scene = pyqtSignal(QGraphicsScene)

    def __init__(self, mutex, cond):

        super(Worker, self).__init__()

        self.mutex = mutex

        self.cond = cond

    '''

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

                    2018.05.28  Jeongwoo    Add Parameter 'xmlPath[0]'

                    2018.05.30  Jeongwoo    Remove import recognizeLine and self.xmlPath and remove parameter on recognizeLine.emit() (xmlPath)

                                            Change signal name (drawDetectedItems)

    '''

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

        try:

            self.mutex.lock()

            if self.isSymbolChecked or self.isTrainingChecked:

                Worker.executeRecognition(self.drawings, self.listWidget, self.isLineChecked, self)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

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

        except:

            (_type, value, traceback) = sys.exc_info()

            sys.excepthook(_type, value, traceback)

        finally:

            self.mutex.unlock()

            self.finished.emit()

    '''

        @brief  remove small objects from given image

        @author humkyung

        @date   2018.04.26

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

    '''

    @staticmethod

    def remove_small_objects(image):

        try:

            app_doc_data = AppDocData.instance()

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

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

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

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

            # try to convert grayscale to binary

            image = cv2.threshold(image, 200, 255, cv2.THRESH_BINARY)[1]

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

            selectedContours = []

            for contour in contours:

                area = cv2.contourArea(contour)

                if minArea < area < maxArea:

                    selectedContours.append(contour)

            # draw contour with white color

            cv2.drawContours(image, selectedContours, -1, (255, 255, 255), -1)

        except Exception as ex:

            from App import App

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return image

    '''

        @brief  arrange line's position

        @author humkyung

        @date   2018.07.04

    '''

    @staticmethod

    def arrangeLinePosition(lines, symbols, listWidget):

        try:

            listWidget.addItem('Apply flow direction')

            pool = [line for line in lines if line.flowMark is not None]

            visited = []

            visited.extend(pool)

            while len(pool) > 0:

                line = pool.pop()

                print('{} - ({})'.format(line, len(pool)))

                rhs = [item for item in lines if item not in visited and item.is_connected(line)]

                if rhs:

                    pool.extend(rhs)

                    visited.extend(rhs)

                    for item in rhs:

                        item.arrangeVertexOrder(line)

                # skip jointed symbols

                symbolPool = [item for item in symbols if item not in visited and item.is_connected(line)]

                if symbolPool:

                    selected = []

                    visited.extend(symbolPool)

                    while len(symbolPool) > 0:

                        symbol = symbolPool.pop()

                        rhs = [item for item in symbols if item not in visited and item.is_connected(symbol)]

                        if rhs:

                            symbolPool.extend(rhs)

                            visited.extend(rhs)

                            selected.extend(rhs)

                        else:

                            selected.append(symbol)

                    # find lines which are connected last symbol

                    for symbol in selected:

                        rhs = [item for item in lines if item not in visited and item.is_connected(symbol)]

                        if rhs:

                            pool.extend(rhs)

                            visited.extend(rhs)

                            for item in rhs:

                                item.arrangeVertexOrder(line)

                # up to here

            # up to here

        except Exception as ex:

            from App import App

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

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

        try:

            QApplication.processEvents()

            self.create_detected_symbol_item(symbolList)

            QApplication.processEvents()

            self.create_detected_text_item(textInfoList)

            QApplication.processEvents()

            self.create_detected_other_text_item(otherTextInfoList)

            QApplication.processEvents()

            self.create_detected_title_block_text_item(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.displayLog.emit(MessageType.Error, message)

    '''

            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 create_detected_symbol_item(self, symbolList):

        from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

        from SymbolSvgItem import SymbolSvgItem

        import math

        try:

            app_doc_data = AppDocData.instance()

            project = app_doc_data.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.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

                    # self.addSvgItemToScene(svg)

                    app_doc_data.symbols.append(svg)

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

                    app_doc_data.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.displayLog.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 create_detected_text_item(self, textInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

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

                    app_doc_data.texts.append(item)

                    app_doc_data.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.displayLog.emit(MessageType.Error, message)

    '''

        @brief      draw detected texts except which in drawing area

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

    '''

    def create_detected_other_text_item(self, otherTextInfoList):

        from TextItemFactory import TextItemFactory

        import math

        try:

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

                    app_doc_data.texts.append(item)

                    app_doc_data.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.displayLog.emit(MessageType.Error, message)

    def create_detected_title_block_text_item(self, textInfoList):

        """draw title block"""

        from TextItemFactory import TextItemFactory

        import math

        try:

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

                        app_doc_data.texts.append(item)

                        app_doc_data.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.displayLog.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 create_unknown_items(self, path):

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringUnknownItem import QEngineeringUnknownItem

        try:

            app_doc_data = AppDocData.instance()

            project = app_doc_data.getCurrentProject()

            windowSize = app_doc_data.getSlidingWindowSize()

            thickness = int(windowSize[1] / 2)

            area = app_doc_data.getArea('Drawing')

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

            # remove line from image

            imgDiff = np.ones(app_doc_data.imgSrc.shape, np.uint8) * 255

            imgDiff[round(area.y + 1):round(area.y + area.height),

                           round(area.x + 1):round(area.x + area.width)] = \

                app_doc_data.imgSrc[round(area.y + 1):round(area.y + area.height),

                           round(area.x + 1):round(area.x + area.width)]

            lines = app_doc_data.lines

            for line in lines:

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

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

            # up to here

            cv2.imwrite(diffFilePath, imgDiff)

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

            cv2.bitwise_not(imgDiff, imgNot)

            configs = app_doc_data.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 = app_doc_data.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

                # 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.determine_remain_object(idx, contours, imgNot)

                if resultStr == 'LineIndicator':

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

                    app_doc_data.lineIndicators.append(item)

                elif resultStr == 'MissingLine':

                    idx += 1

                    continue

                elif resultStr == 'Unknown':

                    item = QEngineeringUnknownItem(approx, 'False')

                    app_doc_data.unknowns.append(item)

                item.area = 'Drawing'

                app_doc_data.allItems.append(item)

                idx += 1

                # up to here

            """

            if app_doc_data.needReOpening is not None:

                app_doc_data.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 = app_doc_data.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 = app_doc_data.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 = app_doc_data.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.determine_remain_object(idx, contours, imgNot)

                    if resultStr == 'LineIndicator':

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

                        app_doc_data.lineIndicators.append(item)

                    elif resultStr == 'MissingLine':

                        pass

                    elif resultStr == 'Unknown':

                        item = QEngineeringUnknownItem(approx, 'False')

                        app_doc_data.unknowns.append(item)

                    item.area = 'Drawing'

                    app_doc_data.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.displayLog.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.displayLog.emit(MessageType.Error, message)

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

        """determine remain objects -> line no indicator or unknown"""

        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.is_line_no_indicator(w, h, maxDifAngle, baseDifV, baseLines, otherLines)

            if result:

                # print(fLines)

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

        return ('Unknown', [])

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

        """determine line no indicator"""

        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)

    def load_equipment_package(self, drawing):

        from LoadCommand import LoadCommand

        try:

            """load equipment package"""

            cmd = LoadCommand()

            cmd.execute((drawing, self.scene), symbol=False, text=False, line=False, unknown=False,

                        package=True ,update=False)

            """up to here"""

        except Exception as ex:

            from App import App

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

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

            App.mainWnd().addMessage.emit(MessageType.Error, message)

    @staticmethod

    def executeRecognition(drawings, listWidget, isLineChecked, worker):

        """recognize symbol, text, line from image p&id"""

        import re

        import timeit

        from TextDetector import TextDetector

        from Drawing import Drawing

        from datetime import datetime

        global ocrCompletedSrc

        global threadLock

        global searchedSymbolList

        global textInfoList

        global maxProgressValue

        try:

            app_doc_data = AppDocData.instance()

            #drawings = app_doc_data.getDrawings()

            project = app_doc_data.getCurrentProject()

            textDetector = TextDetector()

            worker.scene.clear()

            Worker.initTargetSymbolDataList()

            for drawing in drawings:

                ocrCompletedSrc = []

                searchedSymbolList = []

                textInfoList = []

                mainRes = drawing.file_path

                if not os.path.isfile(mainRes):

                    item = QListWidgetItem('{} file is not found'.format(os.path.basename(mainRes)))

                    item.setBackground(Qt.red)

                    listWidget.addItem(item)

                    continue

                app_doc_data.clearItemList(True)

                app_doc_data.setImgFilePath(mainRes)

                app_doc_data.imgSrc = None

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

                app_doc_data.activeDrawing = drawing # matches[0] if matches else Drawing(None, app_doc_data.imgName, None)

                app_doc_data.activeDrawing.set_pid_source(Image.open(mainRes))

                # Load equipment package

                #worker.load_equipment_package(app_doc_data.activeDrawing)

                # remove not drawing area

                configs = app_doc_data.getConfigs('{} Equipment Desc Area'.format(app_doc_data.imgName))

                for config in configs:

                    found = re.findall('\\d+', config.value)

                    if len(found) == 4:

                        cv2.rectangle(app_doc_data.imgSrc, (int(found[0]), int(found[1])),

                                      (int(found[0]) + int(found[2]), int(found[1]) + int(found[3])), 255, -1)

                configs = app_doc_data.getConfigs('{} Typical Area'.format(app_doc_data.imgName))

                for config in configs:

                    found = re.findall('\\d+', config.value)

                    if len(found) == 4:

                        cv2.rectangle(app_doc_data.imgSrc, (int(found[0]), int(found[1])),

                                      (int(found[0]) + int(found[2]), int(found[1]) + int(found[3])), 255, -1)

                noteArea = app_doc_data.getArea('Note')

                if noteArea is not None:

                    noteArea.img = app_doc_data.imgSrc[round(noteArea.y):round(noteArea.y + noteArea.height),

                                   round(noteArea.x):round(noteArea.x + noteArea.width)].copy()

                    cv2.rectangle(app_doc_data.imgSrc, (round(noteArea.x), round(noteArea.y)),

                                  (round(noteArea.x + noteArea.width), round(noteArea.y + noteArea.height)), 255, -1)

                    #cv2.imwrite('c:\\temp\\note.png', noteArea.img)

                    #cv2.imwrite('c:\\temp\\removed_note.png', app_doc_data.imgSrc)

                # up to here

                area = app_doc_data.getArea('Drawing')

                if area is not None:

                    # copy image

                    area.img = app_doc_data.imgSrc[round(area.y):round(area.y + area.height),

                               round(area.x):round(area.x + area.width)]

                    _, area.mask = cv2.threshold(area.img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

                    # area.contours, area.hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

                    area.not_img = cv2.bitwise_not(area.img)

                    area.contours, area.hierachy = cv2.findContours(area.not_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

                maxProgressValue = 0

                start_time = timeit.default_timer()

                listWidget.addItem(f"Start recognition {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} : {mainRes}")

                threadLock.acquire()

                worker.updateBatchProgress.emit(len(drawings), 1)

                if worker.isSymbolChecked:

                    # calculate total count of symbol

                    for targetItem in targetSymbolList:

                        if type(targetItem) is list:

                            maxProgressValue += len(targetItem)

                        else:

                            maxProgressValue += 1

                    # up to here

                    maxProgressValue = maxProgressValue * 2

                threadLock.release()

                if worker.isSymbolChecked:

                    worker.displayTitle.emit(worker.tr('Detecting symbols...'))

                    # detect only equipments

                    with futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER) as pool:

                        future_equipment = {pool.submit(Worker.detectSymbolsOnPid, mainRes, symbol, listWidget, worker):

                                             symbol for symbol in targetSymbolList[0]}

                        futures.wait(future_equipment)

                    # up to here

                    # detect normal symbols

                    with futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER) as pool:

                        future_symbol = {pool.submit(Worker.detectSymbolsOnPid, mainRes, symbol, listWidget, worker):

                                           symbol for symbol in targetSymbolList[2]}

                        futures.wait(future_symbol)

                    # up to here

                    if worker.isTrainingChecked:

                        import uuid

                        worker.displayTitle.emit(worker.tr('Generating Data...'))

                        listWidget.addItem('Generating Data...')

                        for item in searchedSymbolList:

                            path = os.path.join(project.getTempPath(), 'Tile', item.getBaseSymbol())

                            if not os.path.exists(path): os.makedirs(path)

                            _img = app_doc_data.imgSrc[round(item.getSp()[1]):round(item.getSp()[1] + item.getHeight()),

                                   round(item.getSp()[0]):round(item.getSp()[0] + item.getWidth())]

                            cv2.imwrite(os.path.join(path, str(uuid.uuid4()) + '.png'), _img)

                        worker.updateBatchProgress.emit(len(srcList), 4)

                        continue

                    #cv2.imwrite('c:\\temp\\before-imgSrc.png', area.img)

                    # save original image before remove symbol

                    worker.copy_imgSrc = app_doc_data.imgSrc.copy()

                    searchedTextSymList = []

                    for sym in searchedSymbolList:

                        Worker.remove_detected_symbol_image(sym, app_doc_data.imgSrc)

                else:

                    '''

                    import math

                    symbolItems = [item for item in worker.scene.items() if issubclass(type(item), SymbolSvgItem)]

                    for symbolItem in symbolItems:

                        symbolName = symbolItem.name

                        symbolType = symbolItem.type

                        searchedItemSp = [int(symbolItem.loc[0]), int(symbolItem.loc[1])]

                        sw = symbolItem.size[0] # check later

                        sh = symbolItem.size[1] # check later

                        symbolThreshold = 50 # not necessary

                        symbolMinMatchCount = 0 # not necessary

                        hitRate = 80 # not necessary

                        allowed_error = 0.0001

                        #degree 0

                        if abs(symbolItem.angle - 0) <= allowed_error:

                            symbolRotatedAngle = 0

                        #degree 90

                        elif abs(symbolItem.angle - 1.57) <= allowed_error:

                            symbolRotatedAngle = 90

                        #degree 180

                        elif abs(symbolItem.angle - 3.14) <= allowed_error:

                            symbolRotatedAngle = 180

                        #degree 270

                        elif abs(symbolItem.angle - 4.71) <= allowed_error:

                            symbolRotatedAngle = 270

                        else:

                            symbolRotatedAngle = math.pi / 180 * symbolItem.angle

                        isDetectOnOrigin = 80 # not necessary

                        symbolRotateCount = 0 # not necessary

                        symbolOcrOption = 0 # not necessary

                        isContainChild = 0 # not necessary

                        originalPoint = [symbolItem.origin[0] - symbolItem.loc[0], symbolItem.origin[1] - symbolItem.loc[1]]

                        symbolConnectionPoint = []

                        baseSymbol = str(symbolItem.parentSymbol)

                        additionalSymbol = str(symbolItem.childSymbol)

                        isExceptDetect = 0 # not necessary

                        detectFlip = symbolItem.flip

                        searchedSymbolList.append(Symbol(symbolName, symbolType , 

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

                            isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild , 

                            ','.join(str(x) for x in originalPoint), 

                            [], 

                            baseSymbol, additionalSymbol, isExceptDetect, detectFlip))

                        worker.scene.removeItem(symbolItem)

                    pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                    '''

                    # symbolItems = [item for item in worker.scene.items() if issubclass(type(item), SymbolSvgItem)]

                    # appDocData.symbols.extend(symbolItems)

                    # appDocData.allItems.extend(symbolItems)

                    # for sym in searchedSymbolList:

                    #    pool.submit(Worker.remove_detected_symbol_image, sym, appDocData.imgSrc)

                    # pool.shutdown(wait = True)

                worker.updateBatchProgress.emit(len(drawings), 1)

                area = app_doc_data.getArea('Drawing')

                if area is not None:

                    # copy area image

                    area.img = app_doc_data.imgSrc[round(area.y):round(area.y + area.height),

                               round(area.x):round(area.x + area.width)]

                offset = (area.x, area.y) if area is not None else (0, 0)

                otherTextInfoList = None

                titleBlockTextInfoList = None

                textInfoList = []

                if worker.isTextChecked:

                    from TextInfo import TextInfo

                    textAreas, ocr_image = textDetector.detectTextAreas(area.img if area is not None else app_doc_data.imgSrc,

                                                             offset)

                    # get text area by using symbol setting

                    text_area_symbols = []

                    for symbol in [symbol for symbol in searchedSymbolList if symbol.text_area]:

                        symbol_angle = symbol.getRotatedAngle()

                        for text_area in symbol.text_area:

                            so = [symbol.getWidth(), symbol.getHeight()] if symbol_angle is 0 or symbol_angle is 180\

                                            else [symbol.getHeight(), symbol.getWidth()]

                            text_area_origin = Worker.getCalculatedOriginalPoint(None, str(text_area.center()[0]) + ',' + str(text_area.center()[1]),\

                                                                      symbol_angle, None, None, so[0], so[1], symbol.getDetectFlip())

                            x = text_area_origin[0] - round(text_area.width / 2) if symbol_angle is 0 or symbol_angle is 180\

                                else text_area_origin[0] - round(text_area.height / 2)

                            x = x + symbol.sp[0]

                            y = text_area_origin[1] - round(text_area.height / 2) if symbol_angle is 0 or symbol_angle is 180\

                                else text_area_origin[1] - round(text_area.width / 2)

                            y = y + symbol.sp[1]

                            w = text_area.width if symbol_angle is 0 or symbol_angle is 180 else text_area.height

                            h = text_area.height if symbol_angle is 0 or symbol_angle is 180 else text_area.width

                            if symbol_angle is 180 or symbol_angle is 0:

                                text_angle = 0

                            else:

                                text_angle = 90

                            text_area_symbols.append(TextInfo('', x, y, w, h, text_angle))

                    for textArea_index in reversed(range(len(textAreas))):

                        is_pop = False

                        for text_area_index in reversed(range(len(text_area_symbols))):

                            if text_area_symbols[text_area_index].contains(textAreas[textArea_index].center) or \

                                    textAreas[textArea_index].contains(text_area_symbols[text_area_index].center):

                                if text_area_symbols[text_area_index].area > textAreas[textArea_index].area:

                                    textAreas.pop(textArea_index)

                                    is_pop = True

                                    break

                                else:

                                    text_area_symbols.pop(text_area_index)

                                    break

                            if is_pop:

                                break

                    textAreas.extend(text_area_symbols)

                    # up to here

                    if maxProgressValue < 2 * len(textAreas):

                        for _ in range(len(textAreas) - int(maxProgressValue * 0.5)):

                            worker.updateProgress.emit(2 * len(textAreas), None)

                        maxProgressValue = 2 * len(textAreas)

                    else:

                        maxProgressValue = int(maxProgressValue * 0.5) + len(textAreas)

                    worker.displayTitle.emit(worker.tr('Detecting texts...'))

                    textDetector.recognizeText(area.img, offset, textAreas, searchedSymbolList, worker,

                                               listWidget, maxProgressValue)

                    textInfoList = textDetector.textInfoList.copy() if textDetector.textInfoList is not None else None

                    otherTextInfoList = textDetector.otherTextInfoList.copy() if textDetector.otherTextInfoList is not None else None

                    titleBlockTextInfoList = textDetector.titleBlockTextInfoList.copy() if textDetector.titleBlockTextInfoList is not None else None

                    app_doc_data.activeDrawing.width, app_doc_data.activeDrawing.height = \

                        app_doc_data.imgSrc.shape[::-1]

                    app_doc_data.imgName = os.path.splitext(os.path.basename(mainRes))[0]

                else:

                    from LoadCommand import LoadCommand

                    import math

                    from TextInfo import TextInfo

                    """load texts"""

                    cmd = LoadCommand()

                    cmd.execute((drawing, worker.scene), symbol=False, text=True, line=False, unknown=False,

                                package=False, update=False)

                    """up to here"""

                    textItems = [item for item in worker.scene.items() if issubclass(type(item), QEngineeringTextItem)]

                    app_doc_data.texts.extend(textItems)

                    app_doc_data.allItems.extend(textItems)

                    lineNoTextItems = [item for item in textItems if type(item) is QEngineeringLineNoTextItem]

                    for lineNoTextItem in lineNoTextItems:

                        lineNoTextItem.set_property('Freeze', False)

                        # lineNoTextItem.freeze_item.update_freeze(lineNoTextItem.prop('Freeze'))

                        lineNoTextItem.explode()

                    for textItem in textItems:

                        textInfoList.append(

                            TextInfo(textItem.text(), textItem.loc[0], textItem.loc[1], textItem.size[0],

                                     textItem.size[1], round(math.degrees(textItem.angle))))

                        textItem.owner = None

                        worker.scene.removeItem(textItem)

                worker.updateBatchProgress.emit(len(drawings), 2)

                # check symbol validate

                #valid_sym = []

                for index in reversed(range(len(searchedTextSymList))):

                    sym_xmin = searchedTextSymList[index].getSp()[0]

                    sym_ymin = searchedTextSymList[index].getSp()[1]

                    sym_xmax = searchedTextSymList[index].getSp()[0] + searchedTextSymList[index].getWidth()

                    sym_ymax = searchedTextSymList[index].getSp()[1] + searchedTextSymList[index].getHeight()

                    valid_count = searchedTextSymList[index].getHasInstrumentLabel()

                    valid = 0

                    for text_info in textInfoList:

                        info_center = text_info.center

                        if sym_xmin < info_center[0] < sym_xmax and sym_ymin < info_center[1] < sym_ymax:

                            valid += 1

                            break

                            #if valid >= valid_count:

                            #    valid_sym.append(searchedTextSymList[index])

                            #    break

                    if valid < valid_count:

                        searchedSymbolList.pop(searchedSymbolList.index(searchedTextSymList[index]))

                # roll back because invalidated symbol was deleted for text detection

                app_doc_data.imgSrc = worker.copy_imgSrc

                for sym in searchedSymbolList:

                        Worker.remove_detected_symbol_image(sym, app_doc_data.imgSrc)

                #pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                #for sym in valid_sym:

                #    pool.submit(Worker.remove_detected_symbol_image, sym, app_doc_data.imgSrc)

                #pool.shutdown(wait=True)

                # up to here

                # remove text from image

                textDetector.remove_text_from_image(app_doc_data.imgSrc, [0, 0])

                #textDetector.remove_text_from_image(area.img, offset)

                if not worker.isTextChecked:

                    textInfoList.clear()