HYTOS

#region import libs

import http.client

import urllib, base64, json

import cv2

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.image as mpimg

import SymbolBase

import symbol

import TextInfo as ti

import azure_ocr_module as OCR

import azure_handwrite_ocr_module as HOCR

import imutils

from PIL import Image

from PIL import ImageTk

from PIL import ImageChops

from io import BytesIO

from functools import partial

from functools import reduce

import gc

import os

import glob

import timeit

import scipy

import math, operator

import threading

import concurrent.futures as futures

import XmlGenerator as xg

import sqlite3

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

WHITE_LIST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

#DB_NAME = "db/DTI_PID_test.db"

#DB_NAME = AppDocData.instance().getCurrentProject().getPath() + "/db/" + "DTI_PID.db"

#DB_NAME = os.path.dirname(os.path.realpath(__file__)) + "\\db\\DTI_PID.db"

THREAD_MAX_WORKER = 4

threadLock = threading.Lock()

ACCEPT_OVERLAY_AREA = 10

#endregion

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 categoryCode != 99 and (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

def removeText(img, text, x, y, width, height):

    x = int(x)

    y = int(y)

    width = int(width)

    height = int(height)

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

    temp = roi.copy()

    tempBin = cv2.bitwise_not(temp)

    roi = cv2.bitwise_xor(roi, tempBin, roi)

#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    

'''

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

    rx = None

    ry = None

    if rAngle == 0:

        rx = x

        ry = y

    elif rAngle == 90:

        rx = y

        ry = originImageWidth - x

    elif rAngle == 180:

        rx = originImageWidth - x

        ry = originImageHeight - y

    elif rAngle == 270:

        rx = originImageHeight - y

        ry = x

    else:   # general case

        pass

    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"

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

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 = int(symbolOriginalPoint.split(',')[0])

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

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

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

    return originalPoint

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

    convertedConnectionPoint = ""

    splitConnectionPointStr = symbolConnectionPointStr.split("/")

    for index in range(len(splitConnectionPointStr)):

        if index != 0:

            convertedConnectionPoint = convertedConnectionPoint + "/"

        item = splitConnectionPointStr[index]

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

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

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

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

        convertedConnectionPoint = convertedConnectionPoint + temp

    return convertedConnectionPoint

'''

    @brief  Add symbols

    @author jwkim

    @date

'''

def addSearchedSymbol(id, sName, sType

                      , sp, w, h, threshold, minMatchCount, mpCount, rotatedAngle

                      , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                      , originalPoint, connectionPoint, baseSymbol, additionalSymbol):

    global searchedSymbolList

    newSym = symbol.Symbol(id, sName, sType

                           , sp, w, h, threshold, minMatchCount, mpCount, rotatedAngle

                           , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                           , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

##Add symbols

#def addSearchedSymbol(id, sName, sType, symbolPath

#                      , sp, w, h, threshold, minMatchCount, mpCount, rotatedAngle

#                      , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

#                      , originalPoint, connectionPoint, baseSymbol, additionalSymbol):

#    global searchedSymbolList

#    newSym = symbol.Symbol(id, sName, sType, symbolPath

#                           , sp, w, h, threshold, minMatchCount, mpCount, rotatedAngle

#                           , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

#                           , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

    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

#detect symbols on PID

def detectSymbolsOnPid(mainRes, targetSymbols, listWidget):

    for detailTarget in targetSymbols:

        detectSymbolOnPid(mainRes, detailTarget, listWidget)

'''

    @brief      detect symbol on PID

    @author     jwkim

    @date   

    @history    humkyung 2018.04.06 check if symbol file exists

'''

def detectSymbolOnPid(mainRes, targetSymbol, listWidget):

    global src

    global srcGray

    global ocrCompletedSrc

    global afterDenoising

    global threadLock

    global searchedSymbolList

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

    foundSymbolCount = 0

    # check if symbol file exists

    if not os.path.isfile(symbolPath):

        item = QListWidgetItem('{} file not found'.format(symbolPath))

        item.setBackground(QColor('red'))

        listWidget.addItem(item)

        return

    else:

        listWidget.addItem('current symbol : ' + symbolPath)

    # up to here

    sym = cv2.imread(symbolPath, 1)

    symGray = cvtGrayImage(sym)

    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]

    if srcWidth > 10000 or srcHeight > 10000:

        splitCount = 2 ## splitCount = 2^n

    else:

        splitCount = 1

    totalMpCount = 0

    while splitCount >= 1:

        splitWidth = srcWidth // splitCount

        splitHeight = srcHeight // splitCount

        ##Setting ROI List - [splitCount * splitCount] size

        splitRoiList = getSplitSrcList(copiedBasePid, splitCount, splitWidth, splitHeight)

        for roiIndex in range(len(splitRoiList)):

            roiItemSp = splitRoiList[roiIndex][0]

            roiItemEp = splitRoiList[roiIndex][1]

            roiItem = splitRoiList[roiIndex][2]

            symbolRotatedAngle = 0

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

                ##Template Matching

                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

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

                    for i in range(len(searchedSymbolList)):

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

                        if overlapArea > ACCEPT_OVERLAY_AREA:

                            symbolIndex = i

                            break

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

                    mpCount = getMatchPointCount(roi, symGray)

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

                    if overlapArea <= ACCEPT_OVERLAY_AREA:

                        if mpCount >= symbolMinMatchCount:

                            threadLock.acquire()

                            foundSymbolCount = foundSymbolCount + 1

                            totalMpCount = totalMpCount + mpCount

                            addSearchedSymbol(symId, symbolName, symbolType

                                              , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, mpCount, symbolRotatedAngle

                                              , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                              , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

                            threadLock.release()

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

                    else:

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

                            searchedSymbol = searchedSymbolList[symbolIndex]

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

                            if symbolName == searchedSymbol.getName():

                                symbolMpCount = searchedSymbol.getMpCount()

                                if symbolMpCount < mpCount:

                                    threadLock.acquire()

                                    totalMpCount = totalMpCount - symbolMpCount + mpCount

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

                                                                                    , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, mpCount, symbolRotatedAngle

                                                                                    , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                                    , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

                                    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:

                                        symbolMpCount = s.getMpCount()

                                        if symbolMpCount < mpCount:

                                            threadLock.acquire()

                                            totalMpCount = totalMpCount - symbolMpCount + mpCount

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

                                                                                            , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, mpCount, symbolRotatedAngle

                                                                                            , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                                            , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

                                            threadLock.release()

                                else:

                                    if mpCount >= symbolMinMatchCount:

                                        if searchedSymbol.getIsContainChild() == 1:

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

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

                                                continue

                                            else:

                                                threadLock.acquire()

                                                foundSymbolCount = foundSymbolCount + 1

                                                totalMpCount = totalMpCount + mpCount

                                                addSearchedSymbol(symId, symbolName, symbolType

                                                                  , searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount, mpCount, symbolRotatedAngle

                                                                  , isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild

                                                                  , originalPoint, connectionPoint, baseSymbol, additionalSymbol)

                                                threadLock.release()

                ## Rotate Symbol

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

                symbolRotatedAngle = symbolRotatedAngle + 90

                if additionalSymbol is not None:

                    additionalSymbol = getRotatedChildInfo(additionalSymbol)

        splitCount = splitCount // 2

    avgMpCount = 0

    if foundSymbolCount != 0:

        avgMpCount = totalMpCount / foundSymbolCount

    threadLock.acquire()

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

    listWidget.addItem('finish symbol(count) / AvgMpCount : ' + symbolPath + '(' + str(foundSymbolCount) + ') / avgMpCount : ' + str(avgMpCount))

    f = open(os.path.dirname(os.path.realpath(__file__)) + "\\res\\Result\\result_"+srcName+"_600dpi.txt", 'a+')

    data = 'symbolName - (count) : ' + symbolPath + ' - (' + str(foundSymbolCount) + ') / avgMpCount : '+str(avgMpCount)+'\n'

    f.write(data)

    f.close()

    threadLock.release()

def removeDetectedSymbol(sym):

    global srcGray

    global ocrCompletedSrc

    global threadLock

    path = sym.getPath()

    sp = sym.getSp()

    sw = sym.getWidth()

    sh = sym.getHeight()

    sAngle = sym.getRotatedAngle()

    symImg = cv2.imread(path)

    symImg = cvtGrayImage(symImg)

    for i in range(sAngle//90):

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

    threadLock.acquire()

    temp = []

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

    tempBin = cv2.bitwise_not(temp)

    result = cv2.bitwise_xor(symImg, tempBin)

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

    result = cv2.dilate(result, kernel1)

    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)

def drawFoundSymbols(symbol, listWidget):

    global src

    global canvas

    global WHITE_LIST_CHARS

    global searchedSymbolList

    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)

    if (symbolId // 100) == 99: ## Drum

        return    

    if symbolOcrOption == SymbolBase.OCR_OPTION_ALL_FIND or symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

        if symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

            inSqWidth = int(((w//2) * math.cos(round(math.radians(45), 2)))) * 2

            inSqHeight = int(((h//2) * math.sin(round(math.radians(45), 2)))) * 2

            inSqX = w//2 - (inSqWidth//2)

            inSqY = h//2 - (inSqHeight//2)

        else:

            inSqWidth = w

            inSqHeight = h

            inSqX = 0

            inSqY = 0

        roi = src[symbolSp[1]:symbolSp[1]+h, symbolSp[0]:symbolSp[0]+w]

        srcRoi = roi[inSqY:inSqY+inSqHeight, inSqX:inSqX+inSqWidth]

        symRev = cv2.bitwise_not(symImg[inSqY:inSqY+inSqHeight, inSqX:inSqX+inSqWidth])

        bitImg = cv2.bitwise_or(srcRoi, symRev)

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

        bitImg = cv2.dilate(bitImg, kernel1)

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

        #bitImg = cv2.erode(bitImg, kernel2)

        bitImg = cv2.resize(bitImg, None, fx = 2.0, fy = 2.0)

        im = Image.fromarray(bitImg)

        ocrData = pytesseract.image_to_boxes(im, config='-c tessedit_char_whitelist="-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" -psm 6')

        #ocrData = pytesseract.image_to_data(im)

        #ocrData = pytesseract.image_to_string(im, config = "hocr")

        listWidget.addItem("tesseract result : \n" + ocrData)

        ### For image_to_data()

        #if ocrData:

        #    splitOcrData = ocrData.split('\n')

        #    size = len(splitOcrData)

        #    i = 1

        #    while i < size:

        #        data = splitOcrData[i]

        #        threadLock.acquire()

        #        sData = data.split('\t')

        #        if len(sData) == 12:

        #            text = sData[11]

        #            tx = int(sData[6]) // 2

        #            ty = int(sData[7]) // 2

        #            tw = int(sData[8]) // 2

        #            th = int(sData[9]) // 2

        #            realSp = (symbolSp[0]+tx, symbolSp[1]+ty)

        #            cv2.putText(canvas, text, (realSp[0], realSp[1]+th), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 3)

        #        threadLock.release()

        #        i = i+1

        ### For image_to_boxes()

        if ocrData:

            splitOcrData = ocrData.split('\n')

            tList = []

            lastCoord = (-1, -1) # Top-Right Coord

            tText = []

            ftSp = (-1, -1)

            threadLock.acquire()

            for data in splitOcrData:

                sData = data.split(' ')

                text = sData[0]

                tsx = int(sData[1]) // 2

                tsy = int(sData[2]) // 2

                tex = int(sData[3]) // 2

                tey = int(sData[4]) // 2

                tw = tex - tsx

                th = tey - tsy

                MIN_TEXT_SIZE = 10

                if WHITE_LIST_CHARS.find(text) >= 0:

                    if tw >= MIN_TEXT_SIZE or th >= MIN_TEXT_SIZE:

                        realTextSp = (-1, -1)

                        if symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

                            realTextSp = (symbolSp[0]+inSqX+tsx, symbolSp[1]+((h//2) - tsy + inSqY))

                        else:

                            realTextSp = (symbolSp[0]+inSqX+tsx, symbolSp[1]+tsy)

                        #cv2.rectangle(src, realTextSp, (realTextSp[0] + tw, realTextSp[1] + th), (0, 255, 255), 3)

                        removeText(srcGray, text, realTextSp[0], realTextSp[1], tw, th)

                        if lastCoord == (-1, -1):

                            tText.append(text)

                            ftSp = (tsx, tsy)

                        else:

                            COORD_ADJUSTMENT = 15

                            if (abs(lastCoord[1] - tsy) <= COORD_ADJUSTMENT and lastCoord[0] >= tsx - COORD_ADJUSTMENT and lastCoord[0] <= tsx + COORD_ADJUSTMENT) or (abs(lastCoord[0] - tsx) <= COORD_ADJUSTMENT and lastCoord[1] >= tsy - COORD_ADJUSTMENT and lastCoord[1] <= tsy + COORD_ADJUSTMENT):

                                tText.append(text)

                            else:

                                if symbolOcrOption == SymbolBase.OCR_OPTION_ALL_FIND or symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

                                    tText.append(',')

                                tText.append(text)

                        lastCoord = (tex, tsy) # Top-Right Coord

            realSp = (symbolSp[0]+inSqX+ftSp[0], symbolSp[1]+inSqY+ftSp[1])

            realEp = (symbolSp[0]+inSqX+lastCoord[0], symbolSp[1]+inSqY+lastCoord[1])

            resultText = ''.join(tText)

            cv2.putText(canvas, resultText, (realSp[0], realSp[1]+th), 2, 1.0, (0, 0, 0)) # cv2.FONT_HERSHEY_SIMPLEX

            #textInfoList.append(ti.TextInfo(resultText, str(realSp[0]), str(realSp[1]), str(realEp[0]), str(realEp[1])))

            # text value in symbol object update

            index = [i for i, item in enumerate(searchedSymbolList) if item.getSp() == symbolSp]

            if len(index) > 0:

                searchedSymbolList[index[0]].setText(resultText)

            threadLock.release()

def drawFoundSymbolsOnCanvas(mainRes, width, height, listWidget):

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global canvas

    global textInfoList

    canvas = np.zeros((height, width, 3), np.uint8)

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

    #pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

    for symbol in searchedSymbolList:

        #pool.submit(drawFoundSymbols, symbol)

        drawFoundSymbols(symbol, listWidget)

    #pool.shutdown(wait = True)

    for text in textInfoList:

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

            cv2.putText(canvas, text.getText(), (text.getX(), text.getY()+text.getH()), 2, 1.0, (0, 0, 0))

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

    cv2.imwrite(os.path.dirname(os.path.realpath(__file__)) + '\\res\\Result\\result_moved_'+srcName+'_600dpi.png', canvas)

def drawTempLine(sym):

    ADJUST = 8

    symPath = sym.getPath()

    symSp = sym.getSp()

    symWidth = sym.getWidth()

    symHeight = sym.getHeight()

    rotatedAngle = sym.getRotatedAngle()

    symbol = cv2.imread(symPath, 1)

    _chan, sow, soh = symbol.shape[::-1]

    symCp = sym.getConnectionPoint()

    if symCp is not None:

        connectionPointList = symCp.split("/") # x,y string array

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

            symOpStr = sym.getOriginalPoint()

            symOp = (int(symOpStr.split(',')[0]), int(symOpStr.split(',')[1]))

            blank = np.zeros((symWidth, symHeight, 3), np.uint8)

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

            blank = cvtGrayImage(blank)

            bw, bh = blank.shape[::-1]

            srcGray[symSp[1]:symSp[1]+bh, symSp[0]:symSp[0]+bw] = blank

            for cp in connectionPointList:

                pt = cp.split(",")

                cpx = int(pt[0])

                cpy = int(pt[1])

                convertedCp = getCoordOnRotatedImage(rotatedAngle, cpx, cpy, sow, soh)

                newSp = (symSp[0]+convertedCp[0], symSp[1]+convertedCp[1])

                newOp = (symSp[0]+symOp[0], symSp[1]+symOp[1])

                cv2.line(srcGray, newSp, newOp, (0, 0, 0), 3)

#Generate target symbol data list

def initTargetSymbolDataList():

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

    conn = sqlite3.connect(AppDocData.instance().getCurrentProject().getPath() + "/db/" + "ITI_PID.db")

    cursor = conn.cursor()

    sql = 'SELECT * FROM Symbol'

    cursor.execute(sql)

    rows = cursor.fetchall()

    dict = {}

    ## Init Symbol Data from SQLite

    for row in rows:

        symId = row[1] // 100 # symId

        sym = symbol.SymbolBase(row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[0]) ## uid is last item

        #sym = symbol.SymbolBase(row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9], row[10], row[11], row[12], row[13], row[14], row[0]) ## uid is last item

        if symId in dict:

            dict[symId].append(sym)

        else:

            symGroup = []

            symGroup.append(sym)

            dict[symId] = symGroup

    conn.close()

    ## 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      read image drawing and then remove text

    @author     jwkim

    @date       

    @history    humkyung 2018.04.06 check if file exists

'''

def initMainSrc(mainRes):

    global src

    global srcGray

    global ocrCompletedSrc

    global textInfoList

    try:

        if os.path.isfile(mainRes):

            #load original src & symbol

            src = cv2.imread(mainRes, 1)

            #gray scale

            if len(src.shape) == 3:

                srcGray = cvtGrayImage(src)

            else:

                srcGray = src.copy()

            (ocrCompletedSrc, textInfoList) = OCR.removeTextFromNpArray(srcGray)

            for textInfo in textInfoList:

                removeText(ocrCompletedSrc, textInfo.getText(), textInfo.getX(), textInfo.getY(), textInfo.getW(), textInfo.getH())

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

            if area is not None:

                area.img = srcGray[int(area.y):int(area.y+area.height), int(area.x):int(area.x+area.width)]

    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     jwkim

    @date

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

'''

def executeRecognition(path, listWidget):

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global threadLock

    global textInfoList

    res = []

    try:

        project = AppDocData.instance().getCurrentProject()

        srcList = []

        srcList.append(path)

        initTargetSymbolDataList()

        for mainRes in srcList:

            #Init src

            src = []

            srcGray = []

            ocrCompletedSrc = []

            searchedSymbolList = []

            textInfoList = []

            start = timeit.default_timer()

            initMainSrc(mainRes)

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

            #threadLock = threading.Lock()

            pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

            for targetItem in targetSymbolList:

                if type(targetItem).__name__ == 'list':

                    #detectSymbolsOnPid(mainRes, target)

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

                else:

                    #detectSymbolOnPid(mainRes, target)

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

            pool.shutdown(wait = True)

            chan, srcWidth, srcHeight = src.shape[::-1]

            drawFoundSymbolsOnCanvas(mainRes, srcWidth, srcHeight, listWidget)

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

            pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

            for sym in searchedSymbolList:

                #threadLock.acquire()

                pool.submit(removeDetectedSymbol, sym)

                pool.submit(drawRectOnSrc, sym)

                #drawRectOnSrc()

                #threadLock.release()

            pool.shutdown(wait = True)

            (srcGray, tInfoList) = OCR.removeTextFromNpArray(srcGray)

            #srcGray = TOCR.removeTextFromNpArray(srcGray, TOCR.FLAG_IMAGE_TO_DATA)

            for textInfo in textInfoList:

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

                removeText(srcGray, textInfo.getText(), textInfo.getX(), textInfo.getY(), textInfo.getW(), textInfo.getH())

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

            #for sym in searchedSymbolList:

            #    drawTempLine(sym)

            removedSymbolImgPath = project.getTempPath() + '/' + os.path.basename(path)

            cv2.imwrite(removedSymbolImgPath, srcGray)

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

            if area is not None:

                area.img = srcGray[int(area.y):int(area.y+area.height), int(area.x):int(area.x+area.width)]

            cv2.imwrite(project.getTempPath() + "/rect_" + os.path.basename(path), src)

            imgLineList = []

            xmlPath = xg.writeXml(srcName, srcWidth, srcHeight, searchedSymbolList, textInfoList, imgLineList)

            res.append(xmlPath)

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

            stop = timeit.default_timer()    

            seconds = stop - start

            f = open(os.path.dirname(os.path.realpath(__file__)) + "\\res\\Result\\result_"+srcName+"_600dpi.txt", 'a+')

            data = "Running Time : " + str(seconds / 60) + "min\n"

            f.write(data)

            f.close()

            listWidget.addItem("\nRunning Time : " + str(seconds / 60) + "min\n")

    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 res

if __name__ == '__main__':

    import DTI_PID_UI

    from ProjectDialog import Ui_Dialog

    app = QApplication(sys.argv)

    try:

        dlg = Ui_Dialog()

        dlg.show()

        dlg.exec_()

        if dlg.selectedProject is not None:

            form = ExampleApp()

            form.show()

    except Exception as ex:

        print('에러가 발생했습니다.\n', ex)

    sys.exit(app.exec_())