HYTOS

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

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.environ['TESSERACT_HOME'] + '\\tesseract.exe'

tesseract_cmd = 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

'''

    @brief  remove text from image by using ocr image

    @author

'''

def removeText(img, pt, imgOCR):

    x = round(pt[0])

    y = round(pt[1])

    width, height = imgOCR.shape[::-1]

    imgOCR = cv2.dilate(imgOCR, np.ones((1,1), np.uint8))

    imgXOR = cv2.bitwise_xor(img[y:y+height, x:x+width], cv2.bitwise_not(imgOCR))

    imgXOR = cv2.dilate(imgXOR, np.ones((2,2), np.uint8))

    img[y:y+height, x:x+width] = imgXOR

    return img

#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

def getSplitSrcList(srcPid, splitCount, splitWidth, splitHeight):

    splitRoiList = []

    for hi in range(splitCount):

        for wi in range(splitCount):

            roiSp = (splitWidth*wi, splitHeight*hi)

            roiEp = (splitWidth*(wi+1), splitHeight*(hi+1))

            splitRoiList.append((roiSp, roiEp, srcPid[roiSp[1]:roiEp[1], roiSp[0]:roiEp[0]]))

    return splitRoiList

'''

    @history    2018.06.12  Jeongwoo    Type changed (int → float)

'''

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

    originalPoint = ''

    if additionalSymbol is None and symbolOriginalPoint is None:

        originalPoint = str(rotateSymbolWidth//2)+','+str(rotateSymbolHeight//2)

    else:

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

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

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

        originalPoint = str(float(rPt[0])) + ',' + str(float(rPt[1]))

    return originalPoint

'''

    @history    2018.06.12  Jeongwoo    Type changed (int → float)

'''

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

    convertedConnectionPoint = ""

    if symbolConnectionPointStr is not None:

        splitConnectionPointStr = symbolConnectionPointStr.split("/")

        for index in range(len(splitConnectionPointStr)):

            if index != 0:

                convertedConnectionPoint = convertedConnectionPoint + "/"

            item = splitConnectionPointStr[index]

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

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

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

            temp = str(float(rPt[0])) + ',' + str(float(rPt[1]))

            convertedConnectionPoint = convertedConnectionPoint + temp

    return convertedConnectionPoint

'''

    @brief  Add symbols

    @author jwkim

    @date

    @history    Change parameter (mpCount → hitRate)

'''

def addSearchedSymbol(id, sName, sType

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

                      , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

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

    global searchedSymbolList

    newSym = symbol.Symbol(id, sName, sType

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

                           , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                           , originalPoint, connectionPoint, baseSymbol, additionalSymbol, isExceptDetect)

    searchedSymbolList.append(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

'''

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

    global src

    global srcGray

    global ocrCompletedSrc

    global afterDenoising

    global threadLock

    global searchedSymbolList

    global maxProgressValue

    try:

        symId = targetSymbol.getId()

        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=[]

        area = AppDocData.instance().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 = srcGray.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]

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

                    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(symId, 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(symId, symbolName, symbolType

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

                                                                    , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                    , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                                threadLock.release()

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

                        else:

                            ## 검출된 심볼 리스트 중에서 해당 영역에 같은 심볼이 있는지 여부 체크

                            matches = [sym for sym in searchedSymbolList if sym.getName() == symbolName and contains(sym, searchedItemSp, sw, sh) > ACCEPT_OVERLAY_AREA]

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

                            if len(matches) != 0:

                                for s in matches:

                                    symbolHitRate = s.getHitRate()

                                    if symbolHitRate < hitRate:

                                        threadLock.acquire()

                                        searchedSymbolList[searchedSymbolList.index(s)] = symbol.Symbol(symId, symbolName, symbolType

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

                                                                                        , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                                        , originalPoint, connectionPoint, baseSymbol, additionalSymbol,isExceptDetect)

                                        threadLock.release()

                            else:

                                if searchedSymbol.getIsContainChild() == 1:

                                    ##TODO: 특정 카테고리 심볼을 걸러냄 (ex - 9900 대 Drum)

                                    if (searchedSymbol.getId() // 100) == (symId // 100):

                                        continue

                                    else:

                                        threadLock.acquire()

                                        foundSymbolCount = foundSymbolCount + 1

                                        addSearchedSymbol(symId, 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)

    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)

'''

def removeDetectedSymbol(sym):

    global srcGray

    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 = srcGray[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))

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

    ocrCompletedSrc[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.imread(symbolPath, 1)

    for i in range(symbolRotatedAngle//90):

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

    chan, 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 srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global canvas

    canvas = np.zeros(src.shape, np.uint8)

    canvas[::] = (255, 255, 255)

    try:

        docData = AppDocData.instance()

        project = docData.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] = src[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))

#Generate target symbol data list

'''

    @history    2018.04.24  Jeongwoo    Add isExceptDetect Field

                2018.05.09  Jeongwoo    Add targetSymbolList clear

'''

def initTargetSymbolDataList():

    ############ region SQLite

    global targetSymbolList

    targetSymbolList.clear()

    dict = {}

    tempTargetList = AppDocData.instance().getTargetSymbolList()

    ## Init Symbol Data from SQLite

    for target in tempTargetList:

        symId = target.getId() // 100 # symId

        if symId in dict:

            dict[symId].append(target)

        else:

            symGroup = []

            symGroup.append(target)

            dict[symId] = symGroup

    ## Sort each symbol list by symbol id

    for k, v in dict.items():

        dict[k] = sorted(v, key=lambda symbol:symbol.id)

    ## Insert each symbol list into targetSymbolList

    for sym in list(dict.values()):

        targetSymbolList.append(sym)

    ############ endregion SQLite

    return targetSymbolList

'''

    @brief  detect text areas

    @author humkyung

    @date   2018.06.16

'''

def detectTextAreas(filePath):

    global srcGray

    tInfoList = []

    try:

        if os.path.isfile(filePath):

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

            configs = AppDocData.instance().getConfigs('Text Area', 'Text Area')

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

            if type == 0:

                (_tempOcrSrc, tInfoList) = OCR.removeTextFromNpArray(area.img if area is not None else srcGray, area.x if area is not None else 0, area.y if area is not None else 0)

            else:

                tInfoList = getTextAreaInfo(filePath, area.img if area is not None else srcGray, area.x if area is not None else 0, area.y if area is not None else 0)

    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 tInfoList

'''

    @brief      read image drawing and then remove text

    @author     jwkim

    @date       

    @history    humkyung 2018.04.06 check if file exists

                Jeongwoo 2018.05.09 Use Tesseract OCR after Azure OCR (Azure OCR : Getting text area)

                Jeongwoo 2018.05.25 Add condition on if-statement

                Jeongwoo 2018.06.05 Get text area data list by config.type

                Jeongwoo 2018.06.08 Add angle Parameter on TOCR.getTextInfo

                humkyung 2018.06.16 update proessbar while recognizing text

'''

def initMainSrc(mainRes, tInfoList, updateProgressSignal):

    global srcGray

    global ocrCompletedSrc

    global textInfoList

    global noteTextInfoList

    global maxProgressValue

    try:

        docData = AppDocData.instance()

        project = docData.getCurrentProject()

        path = os.path.join(project.getTempPath(), 'OCR_' + os.path.basename(mainRes))

        if os.path.isfile(path):

            ocrCompletedSrc = srcGray.copy()

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

            imgOCR = cv2.imread(path, 1)

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

            global MIN_TEXT_SIZE

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

            for tInfo in tInfoList:

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

                    x = tInfo.getX() - round(area.x)

                    y = tInfo.getY() - round(area.y)

                    img = imgOCR[y:y+tInfo.getH(), x:x+tInfo.getW()]

                    resultTextInfo = TOCR.getTextInfo(img, (x, y), tInfo.getAngle())

                    if resultTextInfo is not None and len(resultTextInfo) > 0:

                        for result in resultTextInfo:

                            result.setX(result.getX() + round(area.x))

                            result.setY(result.getY() + round(area.y))

                        textInfoList.extend(resultTextInfo)

                        ocrCompletedSrc = removeText(ocrCompletedSrc, (tInfo.getX(), tInfo.getY()), img) 

                    else:

                        print(tInfo.getText())

                updateProgressSignal.emit(maxProgressValue)

            cv2.imwrite(os.path.join(project.getTempPath(), "XOCR_" + os.path.basename(mainRes)), ocrCompletedSrc)

        # parse Note

        noteArea = AppDocData.instance().getArea('Note')

        if noteArea is not None:

            noteArea.img = srcGray[round(noteArea.y-1):round(noteArea.y+noteArea.height-1), round(noteArea.x-1):round(noteArea.x+noteArea.width-1)]

            noteTextInfoList = TOCR.getTextInfo(noteArea.img, (noteArea.x, noteArea.y))

        updateProgressSignal.emit(maxProgressValue)

    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  remove small objects from given image

    @author humkyung

    @date   2018.04.26

    @history    2018.05.25  Jeongwoo    Moved from MainWindow

'''

def removeSmallObjects(image):

    try:

        docData = AppDocData.instance()

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

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

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

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

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

        selectedContours=[]

        for contour in contours:

            #if cv2.isContourConvex(contour):

                #approx = cv2.approxPolyDP(contour, 0.2*cv2.arcLength(contour, True), True)

            area = cv2.contourArea(contour)

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

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

        #path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), 'contours.png')

        #cv2.imwrite(path, contourImage)

    except Exception as ex:

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

    return contourImage

'''

    @history    2018.05.25  Jeongwoo    Moved from MainWindow

                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

'''

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:

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

        lineNos = [item for item in graphicsView.scene.items() if type(item) is QEngineeringLineNoTextItem]

        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

        width, height = area.img.shape[::-1]

        size = max(width, height)

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

    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('Finish Line searching')

'''

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

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global threadLock

    global textInfoList

    global noteTextInfoList

    global maxProgressValue

    try:

        docData = AppDocData.instance()

        project = docData.getCurrentProject()

        srcList = []

        srcList.append(path)

        initTargetSymbolDataList()

        for mainRes in srcList:

            #Init src

            src = []

            srcGray = []

            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

            #load original src & symbol

            src = cv2.imread(mainRes, 1)

            #gray scale

            if len(src.shape) == 3:

                srcGray = cvtGrayImage(src)

            else:

                srcGray = src.copy()

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

            area = docData.getArea('Drawing')

            if area is not None:

                #TODO: 영역을 설정한 값과 이미지 좌표계를 차이를 보정

                area.img = srcGray[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()

                textAreas = detectTextAreas(mainRes)

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

                initMainSrc(mainRes, textAreas, updateProgressSignal)

                pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                for targetItem in targetSymbolList:

                    if type(targetItem) is list:

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

                    else:

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

                pool.shutdown(wait = True)

                ## DEBUG

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

                for item in searchedSymbolList:

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

                    _img = srcGray[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

                chan, docData.imgWidth, docData.imgHeight = src.shape[::-1]

                drawFoundSymbolsOnCanvas(mainRes, textInfoList, listWidget)

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

                    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)

                srcGray = cv2.dilate(srcGray, kernel1)

                #kernel2 = np.ones((4, 4), np.uint8)

                srcGray = cv2.erode(srcGray, kernel1)

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

                cv2.imwrite(removedSymbolImgPath, srcGray)

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

                if area is not None:

                    area.img = srcGray[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)), src)

                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 Text Area info by contour

    @author     Jeongwoo

    @date       2018.06.05

    @history    2018.06.08  Jeongwoo    Add angle

                humkyung 2018.06.18 fixed logic to detect text area

'''

def getTextAreaInfo(filePath, imgGray, offsetX, offsetY):

    from AppDocData import AppDocData

    docData = AppDocData.instance()

    project = docData.getCurrentProject()

    configs = docData.getConfigs('Text Size', 'Max Text Size')

    maxTextSize = int(configs[0].value) if 1 == len(configs) else 100

    contourImg = np.ones(imgGray.shape, np.uint8) * 255

    binaryImg,mask = cv2.threshold(imgGray, 127, 255, cv2.THRESH_BINARY)

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

    for contour in contours:

        # remove too big one

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

        if (w > maxTextSize and h > maxTextSize): continue

        area = cv2.contourArea(contour, True)

        if area >= 0:

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

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

        else:

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

    path = os.path.join(project.getTempPath(), 'OCR_' + os.path.basename(filePath))

    cv2.imwrite(path, contourImg)

    rects = []

    configs = docData.getConfigs('Text Recognition', 'Expand Size')

    expandSize = int(configs[0].value) if 1 == len(configs) else 10

    configs = docData.getConfigs('Text Recognition', 'Shrink Size')

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

    eroded = cv2.erode(contourImg, np.ones((expandSize,expandSize), np.uint8))

    path = os.path.join(project.getTempPath(), 'ERODED_OCR_' + os.path.basename(filePath))

    cv2.imwrite(path, eroded)

    eroded = cv2.bitwise_not(eroded)

    image, contours, hierarchy = cv2.findContours(eroded, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)

    for contour in contours:

        area = cv2.contourArea(contour, True)

        if area < 0:

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

            if (w < 10 and h < 10) or (w > maxTextSize and h > maxTextSize): continue; # skip too small or big one

            img = contourImg[y:y+h, x:x+w]

            img = cv2.bitwise_not(img)

            horizontal = 0

            vertical = 0

            if w > maxTextSize:

                horizontal = 1

            elif h > maxTextSize:

                vertical = 1

            else:

                if shrinkSize > 0:

                    img = cv2.erode(img, np.ones((shrinkSize,shrinkSize), np.uint8))

                _, _contours, _ = cv2.findContours(img, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)

                for xx in _contours:

                    [_x, _y, _w, _h] = cv2.boundingRect(xx)

                    cv2.rectangle(img, (_x, _y), (_x+_w, _y+_h), 255, 1)

                    if (_w < _h) or (_w > maxTextSize and _h < maxTextSize): # width is greater than height

                        horizontal += 1 + (_w*_h)/(w*h)

                    else:

                        vertical += 1 + (_w*_h)/(w*h)

            if horizontal > vertical:

                filePath = os.path.join(project.getTempPath(), "Tile", "H-{}-{}-{}-{}.png".format(x,y,w,h))

            else:

                filePath = os.path.join(project.getTempPath(), "Tile", "V-{}-{}-{}-{}.png".format(x,y,w,h))

            cv2.imwrite(filePath, img)

            rects.append([0 if horizontal > vertical else 90, QRect(x, y, w, h)])

    configs = docData.getConfigs('Text Recognition', 'Merge Size')

    mergeSize = int(configs[0].value) if 1 == len(configs) else 10

    # merge rectangles

    intersected = True

    while intersected:

        intersected = False

        for rect in rects[:]:

            if 0 == rect[0]:

                rectExpand = rect[1].adjusted(-mergeSize, 0, mergeSize, 0)

            else:

                rectExpand = rect[1].adjusted(0, -mergeSize, 0, mergeSize)

            matches = [x for x in rects if (x[0] == rect[0]) and rectExpand.intersects(x[1])]

            if len(matches) > 1:

                united = matches[0]

                for _rect in matches:

                    united[1] = united[1].united(_rect[1])

                    if _rect in rects: rects.remove(_rect)

                rects.append(united)

                intersected = True

                break

    list = []

    for rect in rects:

        angle = rect[0]

        list.append(ti.TextInfo('', round(offsetX) + rect[1].x(), round(offsetY) + rect[1].y(), rect[1].width(), rect[1].height(), angle))

    return list

'''

    @brief  get difference between given original and recognized image

    @author humkyung

    @date   2018.06.11

'''

def getDifference(orgImagePath, recImagePath):

    global srcGray

    global ocrCompletedSrc

    global textInfoList

    global noteTextInfoList

    try:

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

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

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

            if area is not None:

                x = round(area.x)

                y = round(area.y)

                width = round(area.width)

                height = round(area.height)

                imgNotOper = cv2.bitwise_not(imgRecognized[y:y+height, x:x+width])

                imgDiff[y:y+height, x:x+width] = cv2.bitwise_xor(imgOriginal[y:y+height, x:x+width], imgNotOper)

            # remove noise

            imgDiff = cv2.dilate(imgDiff, np.ones((2, 2), np.uint8))

            docData = AppDocData.instance()

            project = docData.getCurrentProject()

            cv2.imwrite(os.path.join(project.getTempPath(), "DIFF_" + os.path.basename(orgImagePath)), imgDiff)

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

if __name__ == '__main__':

    import DTI_PID_UI

    from ProjectDialog import Ui_Dialog

    import timeit

    from PyQt5.QtCore import QRect

    from operator import itemgetter, attrgetter

    start = timeit.default_timer()

    img = cv2.imread('D:/Visual Studio Project/DTIPID/DTIPID/DTI_PID/DTI_PID/res/Result/PC-K/PC-K-2203_P1_800DPI.png', 1)

    imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    contourImg = np.ones(imgGray.shape, np.uint8)*255

    contourOcrImg = contourImg.copy()

    binaryImg,mask = cv2.threshold(imgGray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

    imgFinal = cv2.bitwise_and(imgGray, imgGray, mask = mask)

    ret, newImg = cv2.threshold(imgFinal, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

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

    #holes = [contours[i] for i in range(len(contours)) if hierarchy[i][3] >= 0]