HYTOS

# coding: utf-8

#region import libs

import http.client

import urllib, base64, json

import cv2

import numpy as np

import SymbolBase

import symbol

import TextInfo as ti

import azure_ocr_module as OCR

from PIL import Image

from io import BytesIO

import gc

import os

import glob

import math, operator

import threading

import concurrent.futures as futures

import XmlGenerator as xg

import pytesseract

import tesseract_ocr_module as TOCR

import potrace

import sys

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from PyQt5.QtSvg import *

import QtImageViewer

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

import CreateCommand

import CropCommand

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

import QGraphicsPolylineItem

from QEngineeringLineItem import QEngineeringLineItem

from SymbolSvgItem import SymbolSvgItem

from QGraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from AppDocData import AppDocData

#endregion

## Tesseract path

pytesseract.pytesseract.tesseract_cmd = os.path.join(os.environ['TESSERACT_HOME'], 'tesseract.exe')

tesseract_cmd = os.path.join(os.environ['TESSERACT_HOME'], 'tesseract.exe')

#region Symbol Image path List for test

targetSymbolList = []

#endregion

#region Global variables

searchedSymbolList = []

src = []

#srcGray = []

ocrCompletedSrc = []

afterDenoising = []

canvas = []

textInfoList = []

noteTextInfoList = []

WHITE_LIST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

MIN_TEXT_SIZE = 10

THREAD_MAX_WORKER = os.cpu_count()

threadLock = threading.Lock()

ACCEPT_OVERLAY_AREA = 10

#endregion

'''

    @history    2018.06.28  Jeongwoo    Remove useless condition

'''

def checkTextInSymbol(pt):

    global searchedSymbolList

    result = False

    for sym in searchedSymbolList:

        #symId = sym.getId()

        symSp = sym.getSp()

        symWidth = sym.getWidth()

        symHeight = sym.getHeight()

        symOcrOption = sym.getOcrOption()

        categoryCode = symId // 100

        if symOcrOption != SymbolBase.OCR_OPTION_NOT_EXEC:

            if (pt[0] >= symSp[0] and pt[0] <= symSp[0] + symWidth) and (pt[1] >= symSp[1] and pt[1] <= symSp[1] + symHeight):

                result = True

                break

    return result

#Convert into Grayscale image

def cvtGrayImage(img):

    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

'''

    @brief      rotate (x,y) by given angle

    @author     Jeongwoo

    @date       2018.??.??

    @history    humkyung 2018.04.13 fixed code when angle is 90 or 270    

                Jeongwoo 2018.04.27 Change calculation method with QTransform

'''

def getCoordOnRotatedImage(rAngle, x, y, originImageWidth, originImageHeight):

    rx = None

    ry = None

    transform = QTransform()

    if rAngle == 90 or rAngle == 270:

        transform.translate(originImageHeight*0.5, originImageWidth*0.5)

    elif rAngle == 0 or rAngle == 180:

        transform.translate(originImageWidth*0.5, originImageHeight*0.5)

    transform.rotate(-abs(rAngle))

    transform.translate(-originImageWidth*0.5, -originImageHeight*0.5)

    point = QPoint(x, y)

    point = transform.map(point)

    rx = point.x()

    ry = point.y()

    return (rx, ry)

def convertDirectionCodeToValue(directionCode):

    if directionCode == "UP":

        return 0

    elif directionCode == "RIGHT":

        return 1

    elif directionCode == "DOWN":

        return 2

    elif directionCode == "LEFT":

        return 3

    else:

        return -1

def convertValueToDirectionCode(value):

    if value == 0:

        return "UP"

    elif value == 1:

        return "RIGHT"

    elif value == 2:

        return "DOWN"

    elif value == 3:

        return "LEFT"

    else:

        return "NONE"

'''

    @brief      Remake rotated child symbol info

'''

def getRotatedChildInfo(additionalSymbol):

    tempChildInfo = ""

    if additionalSymbol:

        childList = additionalSymbol.split("/")

        for index in range(len(childList)):

            child = childList[index]

            direction = convertDirectionCodeToValue(child.split(",")[0])

            childName = child.split(",")[1]

            direction = (direction - 1) if direction > 0 else 3

            if index != 0:

                tempChildInfo = tempChildInfo + "/"

            tempChildInfo = tempChildInfo + convertValueToDirectionCode(direction) + "," + childName

    return tempChildInfo

#Check object contains pt

#obj is item in searchedSymbolList

def contains(obj, pt, tw, th):

    sp = obj.getSp()

    width = obj.getWidth()

    height = obj.getHeight()

    if sp[0] > pt[0]+tw:

        return 0

    if sp[0]+width < pt[0]: 

        return 0

    if sp[1] > pt[1]+th: 

        return 0

    if sp[1]+height < pt[1]: 

        return 0

    #shared area

    x = max(sp[0], pt[0]);

    y = max(sp[1], pt[1]);

    w = min(sp[0] + width, pt[0] + tw) - x;

    h = min(sp[1] + height, pt[1] + th) - y;

    return float((w * h)) / float((tw * th)) * 100

'''

    @history    2018.06.12  Jeongwoo    Type changed (int → float)

                humkyung 2018.07.07 change return type as like [x,y]

'''

def getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint, symbolRotatedAngle, rotateSymbolWidth, rotateSymbolHeight, originalSymbolWidth, originalSymbolHeight):

    res = []

    if additionalSymbol is None and symbolOriginalPoint is None:

        res.append(rotateSymbolWidth//2)

        res.append(rotateSymbolHeight//2)

    else:

        opx = float(symbolOriginalPoint.split(',')[0])

        opy = float(symbolOriginalPoint.split(',')[1])

        rPt = getCoordOnRotatedImage(symbolRotatedAngle, opx, opy, originalSymbolWidth, originalSymbolHeight)

        res.append(float(rPt[0]))

        res.append(float(rPt[1]))

    return res 

'''

    @history    2018.06.12  Jeongwoo    Type changed (int → float)

                humkyung 2018.07.07 change return type as like [[x,y],...]

'''

def getCalculatedConnectionPoint(symbolConnectionPointStr, symbolRotatedAngle, rotateSymbolWidth, rotateSymbolHeight, originalSymbolWidth, originalSymbolHeight):

    res = []

    if symbolConnectionPointStr is not None:

        splitConnectionPointStr = symbolConnectionPointStr.split("/")

        for index in range(len(splitConnectionPointStr)):

            item = splitConnectionPointStr[index]

            cpx = float(item.split(',')[0])

            cpy = float(item.split(',')[1])

            rPt = getCoordOnRotatedImage(symbolRotatedAngle, cpx, cpy, originalSymbolWidth, originalSymbolHeight)

            res.append([float(rPt[0]), float(rPt[1])])

    return res

'''

    @brief      Add symbols

    @author     jwkim

    @date

    @history    Change parameter (mpCount → hitRate)

                Yecheol 2018.07.04 Delete Symbol Id 

'''

def addSearchedSymbol(sName, sType

                      , sp, w, h, threshold, minMatchCount, hitRate, rotatedAngle

                      , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                      , originalPoint, connectionPoint, baseSymbol, additionalSymbol, isExceptDetect):

    global searchedSymbolList

    newSym = symbol.Symbol(sName, sType

                           , sp, w, h, threshold, minMatchCount, hitRate, rotatedAngle

                           , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                           , ','.join(str(x) for x in originalPoint), '/'.join('{},{}'.format(x[0],x[1]) for x in connectionPoint), baseSymbol, additionalSymbol, isExceptDetect)

    searchedSymbolList.append(newSym)

    return newSym

#Calculate count of keypoint match result

def getMatchPointCount(src, cmp):

    orb = cv2.ORB_create(1000, 2.0, 2, 1)

    kp1, des1 = orb.detectAndCompute(src, None)

    kp2, des2 = orb.detectAndCompute(cmp, None)

    FLANN_INDEX_LSH = 6

    # table_number      : The number of hash tables use

    # key_size          : The length of the key in the hash tables

    # multi_probe_level : Number of levels to use in multi-probe (0 for standard LSH)

    #                     It controls how neighboring buckets are searched

    #                     Recommended value is 2

    # checks            : specifies the maximum leafs to visit when searching for neighbours.

    # LSH : Locality-Sensitive Hashing

    # ref : https://www.cs.ubc.ca/research/flann/uploads/FLANN/flann_manual-1.8.4.pdf

    index_params = dict(algorithm = FLANN_INDEX_LSH, table_number = 20, key_size = 10, multi_probe_level = 4)

    search_params = dict(checks = 100)

    flann = cv2.FlannBasedMatcher(index_params,search_params)

    matches = flann.knnMatch(des1, des2, k = 2)

    matchesMask = [[0, 0] for i in range(len(matches))] #Python 3.x

    count = 0

    # ratio test as per Lowe's paper

    for i in range(len(matches)):

        if len(matches[i]) == 2:

            m = matches[i][0]

            n = matches[i][1]

            if m.distance < 0.85 * n.distance:

                count = count + 1

    matchCount = count

    #print("match Count : " + str(matchCount))

    return matchCount

'''

    @brief   detect symbols on PID

    @history humkyung 2018.06.08 add parameteres for signal

'''

def detectSymbolsOnPid(mainRes, targetSymbols, listWidget, updateProgressSignal):

    for detailTarget in targetSymbols:

        detectSymbolOnPid(mainRes, detailTarget, listWidget, updateProgressSignal)

'''

    @brief      detect symbol on PID

    @author     jwkim

    @date   

    @history    humkyung 2018.04.06 check if symbol file exists

                Jeongwoo 2018.05.29 Change method to adjust detail symbol location with hit-rate. Not feature point count

                                    Change parameter on add symbol part (mpCount → hitRate)

                                    Remove unusing calculation (avg)

                Jeongwoo 2018.06.27 Remove part to split P&ID image and for loop

                humkyung 2018.07.07 return searched symbols

'''

def detectSymbolOnPid(mainRes, targetSymbol, listWidget, updateProgressSignal):

    global ocrCompletedSrc

    global afterDenoising

    global threadLock

    global searchedSymbolList

    global maxProgressValue

    try:

        symbolName = targetSymbol.getName()

        symbolType = targetSymbol.getType()

        symbolPath = targetSymbol.getPath()

        symbolThreshold = targetSymbol.getThreshold()

        symbolMinMatchCount = targetSymbol.getMinMatchCount()

        isDetectOnOrigin = targetSymbol.getIsDetectOnOrigin()

        symbolRotateCount = targetSymbol.getRotationCount()

        symbolOcrOption = targetSymbol.getOcrOption()

        isContainChild = targetSymbol.getIsContainChild()

        symbolOriginalPoint = targetSymbol.getOriginalPoint()

        symbolConnectionPoint = targetSymbol.getConnectionPoint()

        baseSymbol = targetSymbol.getBaseSymbol()

        additionalSymbol = targetSymbol.getAdditionalSymbol()

        isExceptDetect = targetSymbol.getIsExceptDetect()

        # check if symbol file is target or not

        if isExceptDetect == 1:

            item = QListWidgetItem('{} file is not target'.format(os.path.split(os.path.basename(symbolPath))[0]))

            item.setBackground(QColor('green'))

            listWidget.addItem(item)

            return

        foundSymbolCount = 0

        # check if symbol file exists

        if not os.path.isfile(symbolPath):

            item = QListWidgetItem('{} file not found'.format(os.path.split(os.path.basename(symbolPath))[0]))

            item.setBackground(QColor('red'))

            listWidget.addItem(item)

            return

        # up to here

        sym = cv2.imread(symbolPath, 1)

        symGray = cvtGrayImage(sym)

        ## TODO: 이진화 시켰을때 심볼이 검출되지 않음

        ## symGray = cv2.threshold(cvtGrayImage(sym), 127, 255, cv2.THRESH_BINARY)[1]

        ## cv2.imshow('symbol', symGray)

        ## cv2.waitKey(0)

        sow, soh = symGray.shape[::-1] # symbol original w, h

        offsetDrawingArea=[]

        appDocData = AppDocData.instance()

        area = appDocData.getArea('Drawing')

        if area is not None:

            copiedBasePid = area.img.copy()

            offsetDrawingArea.append(area.x)

            offsetDrawingArea.append(area.y)

        else:

            offsetDrawingArea.append(0)

            offsetDrawingArea.append(0)

            if isDetectOnOrigin == 1:

                copiedBasePid = appDocData.imgSrc.copy()

            else:

                copiedBasePid = ocrCompletedSrc.copy()

        srcWidth, srcHeight = copiedBasePid.shape[::-1]

        roiItemSp = (0,0)

        roiItemEp = (srcWidth, srcHeight)

        roiItem = copiedBasePid

        symbolRotatedAngle = 0

        for rc in range(symbolRotateCount + 1): ## Rotation Count를 사용자 기준으로 받아서 1을 더한 후 사용

            sw, sh = symGray.shape[::-1]

            roiw = (roiItemEp[0] - roiItemSp[0])

            roih = (roiItemEp[1] - roiItemSp[1])

            ## Case : Bigger Symbol than Split ROI

            if roiw < sw or roih < sh:

                symGray = cv2.rotate(symGray, cv2.ROTATE_90_COUNTERCLOCKWISE)

                symbolRotatedAngle = symbolRotatedAngle + 90

                if baseSymbol is not None and additionalSymbol is not None:

                    additionalSymbol = getRotatedChildInfo(additionalSymbol)

                continue

            ## get Rotated Original Point

            originalPoint = getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint, symbolRotatedAngle, sw, sh, sow, soh)

            connectionPoint = getCalculatedConnectionPoint(symbolConnectionPoint, symbolRotatedAngle, sw, sh, sow, soh)

            ## Template Matching

            tmRes = cv2.matchTemplate(roiItem, symGray, cv2.TM_CCOEFF_NORMED)

            loc = np.where(tmRes >= symbolThreshold)

            for pt in zip(*loc[::-1]):

                overlapArea = 0

                mpCount = 0 # Match Point Count

                symbolIndex = -1

                roi = roiItem[pt[1]:pt[1]+sh, pt[0]:pt[0]+sw]

                if symbolMinMatchCount > 0:

                    mpCount = getMatchPointCount(roi, symGray)

                    if not (mpCount >= symbolMinMatchCount):

                        continue

                searchedItemSp = (roiItemSp[0]+pt[0] + round(offsetDrawingArea[0]), roiItemSp[1]+pt[1] + round(offsetDrawingArea[1]))

                for i in range(len(searchedSymbolList)):

                    '''

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

                            symbolIndex = i

                            break

                    '''

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

                    if overlapArea > ACCEPT_OVERLAY_AREA:

                        symbolIndex = i

                        break

                hitRate = tmRes[pt[1], pt[0]]

                ## DEBUG

                #print('{}:{}-{}'.format(symbolName, searchedItemSp, hitRate))

                ## up to here

                ## 겹치는 영역이 기준값보다 작을 경우

                if overlapArea <= ACCEPT_OVERLAY_AREA:

                    threadLock.acquire()

                    foundSymbolCount = foundSymbolCount + 1

                    addSearchedSymbol(symbolName, symbolType

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

                        , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                        , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                    threadLock.release()

                ## 겹치는 영역이 기준값보다 클 경우

                else:

                    if symbolIndex != -1 and symbolIndex < len(searchedSymbolList):

                        searchedSymbol = searchedSymbolList[symbolIndex]

                        ## 현재 심볼과 검출된 심볼이 같을 경우 Match Point가 더 높은 정보로 교체

                        if symbolName == searchedSymbol.getName():

                            symbolHitRate = searchedSymbol.getHitRate()

                            if symbolHitRate < hitRate:

                                threadLock.acquire()

                                searchedSymbolList[symbolIndex] = symbol.Symbol(symbolName, symbolType

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

                                                                    , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                    , ','.join(str(x) for x in originalPoint), '/'.join('{},{}'.format(x[0],x[1]) for x in connectionPoint), baseSymbol, additionalSymbol,isExceptDetect)

                                ## DEBUG

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

                                ## up to here

                                threadLock.release()

                        ## 현재 심볼과 검출된 심볼이 같지 않을 경우 (포함)

                        elif appDocData.isEquipmentType(searchedSymbol.getType()):

                            ## DEBUG

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

                            ## up to here

                            threadLock.acquire()

                            foundSymbolCount = foundSymbolCount + 1

                            addSearchedSymbol(symbolName, symbolType

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

                                , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                            threadLock.release()

            ## Rotate Symbol

            symGray = cv2.rotate(symGray, cv2.ROTATE_90_COUNTERCLOCKWISE)

            symbolRotatedAngle = symbolRotatedAngle + 90

            if additionalSymbol is not None:

                additionalSymbol = getRotatedChildInfo(additionalSymbol)

        threadLock.acquire()

        listWidget.addItem('Found Symbol   : ' + os.path.splitext(os.path.basename(symbolPath))[0] + ' - (' + str(foundSymbolCount) + ')')

        threadLock.release()

        updateProgressSignal.emit(maxProgressValue)

        return [symbol for symbol in searchedSymbolList if symbol.getName() == symbolName]

    except Exception as ex:

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

    return []

'''

    @brief      detect nozzle

    @author     humkyung

    @date       2018.07.07

    @history    humkyhung 2018.07.17 pass equpment as parameter instead of image

'''

def detectNozzleOnPid(equipment, nozzle, listWidget, updateProgressSignal):

    global src

    global threadLock

    global searchedSymbolList

    global maxProgressValue

    try:

        symbolName = nozzle.getName()

        symbolType = nozzle.getType()

        symbolPath = nozzle.getPath()

        symbolThreshold = nozzle.getThreshold()

        symbolMinMatchCount = nozzle.getMinMatchCount()

        isDetectOnOrigin = nozzle.getIsDetectOnOrigin()

        symbolRotateCount = nozzle.getRotationCount()

        symbolOcrOption = nozzle.getOcrOption()

        isContainChild = nozzle.getIsContainChild()

        symbolOriginalPoint = nozzle.getOriginalPoint()

        symbolConnectionPoint = nozzle.getConnectionPoint()

        baseSymbol = nozzle.getBaseSymbol()

        additionalSymbol = nozzle.getAdditionalSymbol()

        isExceptDetect = nozzle.getIsExceptDetect()

        foundSymbolCount = 0

        # check if symbol file exists

        if not os.path.isfile(symbolPath):

            item = QListWidgetItem('{} file not found'.format(os.path.split(os.path.basename(symbolPath))[0]))

            item.setBackground(QColor('red'))

            listWidget.addItem(item)

            return

        # up to here

        symGray = cvtGrayImage(cv2.imread(symbolPath, 1))

        sow, soh = symGray.shape[::-1] # symbol original w, h

        # get image of equipment with offset of nozzle size

        appDocData = AppDocData.instance()

        pt = equipment.getSp()

        nozzleSize = max(sow, soh)

        sx = round(pt[0]) - nozzleSize

        sy = round(pt[1]) - nozzleSize

        ex = round(pt[0] + equipment.getWidth()) + nozzleSize

        ey = round(pt[1] + equipment.getHeight()) + nozzleSize

        offset = (sx, sy)

        eqpSize = (pt[0], pt[1], equipment.getWidth(), equipment.getHeight())

        img = appDocData.imgSrc[sy:ey, sx:ex]

        srcWidth, srcHeight = img.shape[::-1]

        # up to here

        roiItemSp = (0,0)

        roiItemEp = (srcWidth, srcHeight)

        roiItem = img 

        symbolAngle = 0

        for rc in range(symbolRotateCount + 1): ## Rotation Count를 사용자 기준으로 받아서 1을 더한 후 사용

            sw, sh = symGray.shape[::-1]

            roiw = (roiItemEp[0] - roiItemSp[0])

            roih = (roiItemEp[1] - roiItemSp[1])

            ## get Rotated Original Point

            originalPoint = getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint, symbolAngle, sw, sh, sow, soh)

            connectionPoint = getCalculatedConnectionPoint(symbolConnectionPoint, symbolAngle, sw, sh, sow, soh)

            dx = connectionPoint[0][0] - originalPoint[0]

            dy = connectionPoint[0][1] - originalPoint[1]

            ## Template Matching

            tmRes = cv2.matchTemplate(roiItem, symGray, cv2.TM_CCOEFF_NORMED)

            loc = np.where(tmRes >= symbolThreshold)

            for pt in zip(*loc[::-1]):

                mpCount = 0 # Match Point Count

                symbolIndex = -1

                roi = roiItem[pt[1]:pt[1]+sh, pt[0]:pt[0]+sw]

                if symbolMinMatchCount > 0:

                    mpCount = getMatchPointCount(roi, symGray)

                    if not (mpCount >= symbolMinMatchCount):

                        continue

                mid = (offset[0] + pt[0] + (originalPoint[0] + connectionPoint[0][0])*0.5, offset[1] + pt[1] + (originalPoint[1] + connectionPoint[0][1])*0.5) 

                searchedItemSp = (roiItemSp[0]+pt[0]+offset[0], roiItemSp[1]+pt[1]+offset[1])

                print('---{}---{}---{}---'.format(eqpSize,searchedItemSp,mid))

                # check searched nozzle location

                if abs(dx) > abs(dy):

                    if dx > 0:

                        if mid[0] < eqpSize[0] + eqpSize[2]*0.5: continue

                    else:

                        if mid[0] > eqpSize[0] + eqpSize[2]*0.5: continue

                else:

                    if dy > 0:

                        if mid[1] < eqpSize[1] + eqpSize[3]*0.5: continue

                    else:

                        if mid[1] > eqpSize[1] + eqpSize[3]*0.5: continue

                # up to here

                overlapArea = 0

                nozzles = [symbol for symbol in searchedSymbolList if symbol.getType() == 'Nozzles']

                for i in range(len(nozzles)):

                    _pt = nozzles[i].getSp()

                    rect = QRectF(_pt[0], _pt[1], nozzles[i].getWidth(), nozzles[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 > ACCEPT_OVERLAY_AREA:

                            symbolIndex = i

                            break

                hitRate = tmRes[pt[1], pt[0]]

                ## 겹치는 영역이 기준값보다 작을 경우

                if overlapArea <= ACCEPT_OVERLAY_AREA:

                    threadLock.acquire()

                    foundSymbolCount = foundSymbolCount + 1

                    searched = addSearchedSymbol(symbolName, symbolType

                        , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, hitRate, symbolAngle

                        , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                        , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                    searched.owner = equipment

                    threadLock.release()

                ## 겹치는 영역이 기준값보다 클 경우

                else:

                    if symbolIndex != -1 and symbolIndex < len(nozzles):

                        searchedSymbol = nozzles[symbolIndex]

                        ## 현재 심볼과 검출된 심볼이 같을 경우 Match Point가 더 높은 정보로 교체

                        if symbolName == searchedSymbol.getName():

                            symbolHitRate = searchedSymbol.getHitRate()

                            if symbolHitRate < hitRate:

                                threadLock.acquire()

                                nozzles[symbolIndex] = symbol.Symbol(symbolName, symbolType

                                                                    , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, hitRate, symbolAngle

                                                                    , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                    , ','.join(str(x) for x in originalPoint), '/'.join('{},{}'.format(x[0],x[1]) for x in connectionPoint), baseSymbol, additionalSymbol,isExceptDetect)

                                threadLock.release()

                        ## 현재 심볼과 검출된 심볼이 같지 않을 경우 (포함)

                        elif appDocData.isEquipmentType(searchedSymbol.getType()):

                            threadLock.acquire()

                            foundSymbolCount = foundSymbolCount + 1

                            searched = addSearchedSymbol(symbolName, symbolType

                                , searchedItemSp, sw, sh, symbolThreshold, hitRate, hitRate, symbolAngle

                                , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                            searched.owner = equipment

                            threadLock.release()

            ## Rotate Symbol

            symGray = cv2.rotate(symGray, cv2.ROTATE_90_COUNTERCLOCKWISE)

            symbolAngle = symbolAngle + 90

            if additionalSymbol is not None:

                additionalSymbol = getRotatedChildInfo(additionalSymbol)

        threadLock.acquire()

        listWidget.addItem('Found Symbol   : ' + os.path.splitext(os.path.basename(symbolPath))[0] + ' - (' + str(foundSymbolCount) + ')')

        threadLock.release()

        updateProgressSignal.emit(maxProgressValue)

        return [symbol for symbol in searchedSymbolList if symbol.getName() == symbolName]

    except Exception as ex:

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

    return []

'''

    @brief  detect equipment

    @author humkyung

    @date   2018.07.07

'''

def detectEquipmentOnPid(mainRes, targetSymbol, listWidget, updateProgressSignal):

    try:

        equipments = detectSymbolOnPid(mainRes, targetSymbol, listWidget, updateProgressSignal)

        for equipment in equipments:

            # detect nozzles around equimpent

            for nozzle in targetSymbolList[1]:

                detectNozzleOnPid(equipment, nozzle, listWidget, updateProgressSignal)

            # up to here

    except Exception as ex:

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

'''

    @history    2018.05.17  Jeongwoo    Bitwise_not target changed (Original Image → Symbol Image)

                humkyung 2018.07.11 add parameter for image

'''

def removeDetectedSymbol(sym, imgSrc):

    global ocrCompletedSrc

    global threadLock

    path = sym.getPath()

    sp = sym.getSp()

    sw = sym.getWidth()

    sh = sym.getHeight()

    angle = sym.getRotatedAngle()

    symImg = cv2.imread(path)

    symImg = cv2.threshold(cvtGrayImage(symImg), 127, 255, cv2.THRESH_BINARY)[1]

    for i in range(angle//90):

        symImg = cv2.rotate(symImg, cv2.ROTATE_90_COUNTERCLOCKWISE)

    threadLock.acquire()

    temp = []

    temp = imgSrc[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw]

    symImgBin = cv2.bitwise_not(symImg)

    result = cv2.bitwise_xor(symImgBin, temp)

    result = cv2.dilate(result, np.ones((5, 5), np.uint8))

    imgSrc[sp[1]:sp[1]+sh, sp[0]:sp[0]+sw] = result

    threadLock.release()

'''

def drawRectOnSrc(sym):

    global src

    global srcGray

    global ocrCompletedSrc

    path = sym.getPath()

    sp = sym.getSp()

    sw = sym.getWidth()

    sh = sym.getHeight()

    sAngle = sym.getRotatedAngle()

    symImg = cv2.imread(path)

    symImg = cvtGrayImage(symImg)

    cv2.rectangle(src, sp, (sp[0]+sw, sp[1]+sh), (0, 0, 255), 2)

'''

'''

    @history    2018.04.27  Jeongwoo    Remove Tesseract Log on listWidget

                2018.05.04  Jeongwoo    Change method to OCR with tesseract_ocr_module.py

                2018.05.09  Jeongwoo    Add global variable textInfoList, Remove text in symbol and Add tesseract result text

                2018.05.10  Jeongwoo    Remove not used if-statement

                2018.06.19  Jeongwoo    When detect text in symbol, use getTextAreaInfo() and Tesseract

                2018.06.21  Jeongwoo    Add if-statement for way to detect text by Type A

'''

def drawFoundSymbols(symbol, listWidget):

    global src

    global canvas

    global WHITE_LIST_CHARS

    global searchedSymbolList

    global textInfoList

    #symbolId = symbol.getId()

    symbolPath = symbol.getPath()

    symbolSp = symbol.getSp()

    symbolWidth = symbol.getWidth()

    symbolHeight = symbol.getHeight()

    symbolRotatedAngle = symbol.getRotatedAngle()

    symbolOcrOption = symbol.getOcrOption()

    symImg = cv2.cvtColor(cv2.imread(symbolPath, 1), cv2.COLOR_BGR2GRAY)

    for i in range(symbolRotatedAngle//90):

        symImg = cv2.rotate(symImg, cv2.ROTATE_90_COUNTERCLOCKWISE)

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

    canvas[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w] = cv2.bitwise_and(canvas[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w], symImg)

'''

    @brief  draw found symbols and texts

    @author Jeongwoo

'''

def drawFoundSymbolsOnCanvas(drawingPath , textInfos , listWidget):

    global src

    global ocrCompletedSrc

    global searchedSymbolList

    global canvas

    appDocData = AppDocData.instance()

    canvas = np.zeros(appDocData.imgSrc.shape, np.uint8)

    canvas[::] = 255

    try:

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        for symbol in searchedSymbolList:

            drawFoundSymbols(symbol, listWidget)

        for text in textInfos:

            #if not checkTextInSymbol((text.getX(), text.getY())):

            left = text.getX()

            top = text.getY()

            right = text.getX() + text.getW()

            bottom = text.getY() + text.getH()

            canvas[top:bottom, left:right] = appDocData.imgSrc[top:bottom, left:right]

        cv2.imwrite(os.path.join(project.getTempPath(), "FOUND_" + os.path.basename(drawingPath)), canvas)

    except Exception as ex:

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

'''

    @history    2018.04.24  Jeongwoo    Add isExceptDetect Field

                2018.05.09  Jeongwoo    Add targetSymbolList clear

                humkyung 2018.07.07 store symbols to list as like [equipments],[nozzles],[symbols]

'''

def initTargetSymbolDataList():

    global targetSymbolList

    targetSymbolList.clear()

    appDocData = AppDocData.instance()

    symbolList = appDocData.getTargetSymbolList()

    equipments = [item for item in symbolList if appDocData.getSymbolCategoryByType(item.getType()) == 'Equipment']

    nozzles = [item for item in symbolList if item.getType() == 'Nozzles']

    # [[equipments],[nozzles],[symbols]]

    targetSymbolList.append(equipments)

    targetSymbolList.append(nozzles)

    targetSymbolList.append([item for item in symbolList if item not in equipments and item not in nozzles])

    return targetSymbolList

'''

    @brief  remove small objects from given image

    @author humkyung

    @date   2018.04.26

    @history    2018.05.25  Jeongwoo    Moved from MainWindow

'''

def removeSmallObjects(image):

    try:

        appDocData = AppDocData.instance()

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

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

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

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

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

        selectedContours=[]

        for contour in contours:

            area = cv2.contourArea(contour)

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

        contourImage = cv2.drawContours(image, selectedContours, -1, (255,255,255), -1); # draw contour with white color

    except Exception as ex:

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

    return contourImage

'''

    @history    2018.05.25  Jeongwoo    Moved from MainWindow

                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(path, listWidget, graphicsView):

    from shapely.geometry import Point, LineString

    from SymbolSvgItem import SymbolSvgItem

    from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

    from QEngineeringLineNoTextItem import QEngineeringLineNoTextItem

    from QEngineeringTextItem import QEngineeringTextItem

    from QEngineeringLineItem 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 graphicsView.scene.items() if (type(item) is QEngineeringLineItem) or (type(item) is QEngineeringFlowArrowItem)]

        for item in items:

            graphicsView.scene.removeItem(item)

        #up to here

        # detect line

        connectedLines = []

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

        area.img = removeSmallObjects(area.img)

        detector = LineDetector(area.img)

        symbols = []

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

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

            # up to here

            # connect line to line

            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:

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

            # up to here

        lines = []

        for pts in connectedLines:

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

            processLine.buildItem()

            processLine.addLineItemToScene(graphicsView.scene)

            lines.append(processLine)

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

                processLine.addFlowArrow()

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

        arrangeLinePosition(lines, symbols, listWidget)

        # up to here

    except Exception as ex:

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

    finally:

        listWidget.addItem('Finished line recognization')

'''

    @brief  arrange line's position

    @author humkyung

    @date   2018.07.04

'''

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.isJointed(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.isJointed(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.isJointed(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.isJointed(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:

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

'''

    @brief      Main function

    @author     Jeongwoo

    @date

    @history    humkyung 2018.04.06 change error display from message box to print

                Jeongwoo 2018.04.25 Remove 'Current Symbol : ' QListItem

                Jeongwoo 2018.05.09 Make Comments OCR.removeTextFromNpArray block

                Jeongwoo 2018.05.25 Remove imgLineList variable and parameter on writeXml()

                humkyung 2018.05.26 add parameters(graphicsView, isSymbolTextChecked, isLineChecked)

                Jeongwoo 2018.05.28 Add/Remove Parameters(Add : signal / Remove : graphicsView, isLineChecked)

                Jeongwoo 2018.05.30 Remove return value

                humkyung 2018.06.08 add signal for progressbar to parameter

                humkyung 2018.06.11 get difference between original and recognized image

                Jeongwoo 2018.06.21 If noteTextInfoList is None, change from None to empty list

'''

def executeRecognition(signal, updateProgressSignal, path, listWidget, isSymbolTextChecked):

    import re

    from TextDetector import TextDetector

    global ocrCompletedSrc

    global searchedSymbolList

    global threadLock

    global textInfoList

    global noteTextInfoList

    global maxProgressValue

    try:

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        textDetector = TextDetector()

        srcList = []

        srcList.append(path)

        initTargetSymbolDataList()

        for mainRes in srcList:

            ocrCompletedSrc = []

            searchedSymbolList = []

            textInfoList = []

            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

            # remove equipment desc. area

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

            for config in configs:

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

                if len(found) == 4:

                    cv2.rectangle(appDocData.imgSrc, (int(found[0]), int(found[1])), (int(found[0])+int(found[2]), int(found[1])+int(found[3])), 255, -1)

            # up to here

            area = appDocData.getArea('Drawing')

            if area is not None:

                area.img = appDocData.imgSrc[round(area.y):round(area.y+area.height), round(area.x):round(area.x+area.width)]

            listWidget.addItem("Start recognition : " + mainRes)

            if isSymbolTextChecked:

                threadLock.acquire()

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

                textAreas = textDetector.detectTextAreas(area.img if area is not None else appDocData.imgSrc, offset)

                ### calculate total count of symbol

                maxProgressValue = len(textAreas) + 1 

                for targetItem in targetSymbolList:

                    if type(targetItem) is list:

                        maxProgressValue += len(targetItem)

                    else:

                        maxProgressValue += 1

                ### up to here

                threadLock.release()

                # detect equipments

                pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                for symbol in targetSymbolList[0]:

                    pool.submit(detectEquipmentOnPid, mainRes, symbol, listWidget, updateProgressSignal)

                pool.shutdown(wait = True)

                # up to here

                pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                for symbol in targetSymbolList[2]:

                    if type(symbol) is list:

                        pool.submit(detectSymbolsOnPid, mainRes, symbol, listWidget, updateProgressSignal)

                    else:

                        pool.submit(detectSymbolOnPid, mainRes, symbol, listWidget, updateProgressSignal)

                pool.shutdown(wait = True)

                ## DEBUG

                print('----------')

                for item in searchedSymbolList:

                    print('{}:{}-{}'.format(item.getName(), item.getSp(), item.hitRate))

                    _img = appDocData.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(project.getTempPath(), 'Tile', item.getName()+'.png'), _img)

                ## up to here

                textDetector.recognizeText(appDocData.imgSrc, offset, textAreas, searchedSymbolList, updateProgressSignal, listWidget, maxProgressValue)

                textInfoList = textDetector.textInfoList.copy()

                noteTextInfoList = textDetector.noteTextInfoList.copy()

                appDocData.imgWidth, appDocData.imgHeight = appDocData.imgSrc.shape[::-1]

                drawFoundSymbolsOnCanvas(mainRes, textInfoList, listWidget)

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

                pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                for sym in searchedSymbolList:

                    pool.submit(removeDetectedSymbol, sym, appDocData.imgSrc)

                    #pool.submit(drawRectOnSrc, sym)

                pool.shutdown(wait = True)

                '''

                global MIN_TEXT_SIZE

                for textInfo in textInfoList:

                    if textInfo.getW() >= MIN_TEXT_SIZE or textInfo.getH() >= MIN_TEXT_SIZE:

                        removeText(srcGray, (textInfo.getX(), textInfo.getY()), srcGray[textInfo.getY():textInfo.getY()+textInfo.getH(), textInfo.getX():textInfo.getX()+textInfo.getW()])

                '''

                ## Remove Noise

                kernel1 = np.ones((2, 2), np.uint8)

                appDocData.imgSrc = cv2.dilate(appDocData.imgSrc, kernel1)

                appDocData.imgSrc = cv2.erode(appDocData.imgSrc, kernel1)

                removedSymbolImgPath = os.path.join(project.getTempPath(), os.path.basename(path))

                cv2.imwrite(removedSymbolImgPath, appDocData.imgSrc)

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

                if area is not None:

                    area.img = appDocData.imgSrc[round(area.y+1):round(area.y+area.height), round(area.x+1):round(area.x+area.width)]

                cv2.imwrite(os.path.join(project.getTempPath(), "RECT_" + os.path.basename(path)), appDocData.imgSrc)

                listWidget.addItem("Recognized symbol count : " + str(len(searchedSymbolList)))

                # get difference between original and recognized image

                foundFilePath = os.path.join(project.getTempPath(), "FOUND_" + os.path.basename(path))

                getDifference(path, foundFilePath)

                # up to here

                signal.emit(searchedSymbolList, textInfoList, noteTextInfoList if noteTextInfoList is not None else [])

    except Exception as ex:

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

'''

    @brief      draw contour to image

    @author     humkyung

    @date       2018.06.18

'''

def drawContour(img, contour):

    area = cv2.contourArea(contour, True)

    if area >= 0:

        cv2.drawContours(img, [contour], -1, (0,0,0), -1)

        cv2.drawContours(img, [contour], -1, (255,255,255), 1)

    else:

        cv2.drawContours(img, [contour], -1, (255,255,255), -1)

'''

    @brief  get difference between given original and recognized image

    @author humkyung

    @date   2018.06.11

'''

def getDifference(orgImagePath, recImagePath):

    import re

    global ocrCompletedSrc

    global textInfoList

    global noteTextInfoList

    try:

        appDocData = AppDocData.instance()

        if os.path.isfile(orgImagePath) and os.path.isfile(recImagePath):

            imgOriginal = cv2.threshold(cvtGrayImage(cv2.imread(orgImagePath, 1)), 127, 255, cv2.THRESH_BINARY)[1]

            # remove equipment desc. area

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

            for config in configs:

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

                if len(found) == 4:

                    cv2.rectangle(imgOriginal, (int(found[0]), int(found[1])), (int(found[0])+int(found[2]), int(found[1])+int(found[3])), 255, -1)

            # up to here

            imgRecognized = cv2.threshold(cvtGrayImage(cv2.imread(recImagePath, 1)), 127, 255, cv2.THRESH_BINARY)[1]

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

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