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 timeit

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

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

    img[y:y+height, x:x+width] = cv2.bitwise_xor(roi, tempBin)

    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"

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

    if symbolConnectionPointStr is not None:

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

    global searchedSymbolList

    newSym = symbol.Symbol(id, sName, sType

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

                           , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

                           , originalPoint, connectionPoint, baseSymbol, additionalSymbol, isExceptDetect)

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

    isExceptDetect = targetSymbol.getIsExceptDetect()

    if isExceptDetect == 1:

        item = QListWidgetItem('{} file is not target'.format(os.path.basename(symbolPath.replace('.png', ''))))

        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.basename(symbolPath.replace('.png', ''))))

        item.setBackground(QColor('red'))

        listWidget.addItem(item)

        return

    #else:

    #    listWidget.addItem('Current symbol : ' + os.path.basename(symbolPath.replace('.png', '')))

    # 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] + round(offsetDrawingArea[0]) + 1, roiItemSp[1]+pt[1] + round(offsetDrawingArea[1]) + 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,isExceptDetect)

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

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

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

                                                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   : ' + os.path.basename(symbolPath.replace('.png', '')) + ' - (' + str(foundSymbolCount) + ')')

    threadLock.release()

'''

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

    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]

    symImgBin = cv2.bitwise_not(symImg)

    result = cv2.bitwise_xor(symImgBin, temp)

    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)

'''

    @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

'''

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)

    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)

        try:

            threadLock.acquire()

            im = Image.fromarray(bitImg)

            sp = (0, 0)

            if symbolOcrOption == SymbolBase.OCR_OPTION_HALF_AND_HALF:

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

            else:

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

            tList = TOCR.getTextInfoInSymbol(bitImg, sp)

            resultText = ''

            if tList is not None:

                for index in range(len(tList)):

                    textInfo = tList[index]

                    if index != 0:

                        resultText = resultText + ","

                    resultText = resultText + textInfo.getText()

                    cv2.putText(canvas, textInfo.getText(), (textInfo.getX(), textInfo.getY()), 2, 1.0, (0, 0, 0)) # cv2.FONT_HERSHEY_SIMPLEX

                # Sub List textInfo in symbol

                tempList = []

                for textInfo in textInfoList:

                    tx = textInfo.getX()

                    ty = textInfo.getY()

                    if (tx >= symbolSp[0] and tx <= symbolSp[0] + symbolWidth) and (ty >= symbolSp[1] and ty <= symbolSp[1] + symbolHeight):

                        tempList.append(textInfo)

                # Remove textInfo

                for textInfo in tempList:

                    textInfoList.remove(textInfo)

                # Append Tesseract result

                textInfoList.extend(tList)

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

        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:

            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)

    try:

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

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

'''

def initMainSrc(mainRes):

    global src

    global srcGray

    global ocrCompletedSrc

    global textInfoList

    global noteTextInfoList

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

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

            ocrCompletedSrc = srcGray.copy()

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

            if area is not None:

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

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

            #(_tempOcrSrc, textInfoList) = 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)

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

            global MIN_TEXT_SIZE

            for tInfo in tInfoList:

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

                    resultTextInfo = TOCR.getTextInfo(ocrCompletedSrc[tInfo.getY():tInfo.getY()+tInfo.getH(),tInfo.getX():tInfo.getX()+tInfo.getW()], (tInfo.getX(), tInfo.getY()))

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

                        textInfoList.extend(resultTextInfo)

                        ocrCompletedSrc = removeText(ocrCompletedSrc, resultTextInfo[0].getText(), resultTextInfo[0].getX(), resultTextInfo[0].getY(), resultTextInfo[0].getW(), resultTextInfo[0].getH())

                    else:

                        print(tInfo.getText())

            #global MIN_TEXT_SIZE

            #for textInfo in textInfoList:

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

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

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

                #(_tempNoteOcrSrc, noteTextInfoList) = OCR.removeTextFromNpArray(noteArea.img, noteArea.x, noteArea.y)

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

    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

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

'''

def executeRecognition(path, listWidget):

    global src

    global srcGray

    global ocrCompletedSrc

    global searchedSymbolList

    global threadLock

    global textInfoList

    global noteTextInfoList

    res = []

    try:

        docData = AppDocData.instance()

        project = docData.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, docData.imgWidth, docData.imgHeight = src.shape[::-1]

            drawFoundSymbolsOnCanvas(mainRes, docData.imgWidth, docData.imgHeight, listWidget)

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

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

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

            #####(srcGray, tInfoList) = OCR.removeTextFromNpArray(area.img if area is not None else srcGray)

            ####if area is not None:

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

            ####else:

            ####    srcGray = _tempOcrSrc

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

            global MIN_TEXT_SIZE

            for textInfo in textInfoList:

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

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

                    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)

            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)

            xmlPath = xg.writeXml(docData.imgName, docData.imgWidth, docData.imgHeight, searchedSymbolList, textInfoList, noteTextInfoList)

            res.append(xmlPath)

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

            #stop = timeit.default_timer()    

            #seconds = stop - start

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

        selectedProject = dlg.showDialog()

        if selectedProject is not None:

            form = ExampleApp()

            form.show()

    except Exception as ex:

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

    sys.exit(app.exec_())