HYTOS

# coding: utf-8

"""

    This is recognition dialog module

"""

import sys

import os

import threading

import cv2

import numpy as np

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

import Recognition_UI

import concurrent.futures as futures

from AppDocData import *

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from QEngineeringOPCItem import QEngineeringOPCItem

from LineDetector import LineDetector

from symbol import Symbol

from MainWindow import MainWindow

# region Symbol Image path List for test

targetSymbolList = []

# endregion

# region Global variables

searchedSymbolList = []

textInfoList = []

src = []

ocrCompletedSrc = []

afterDenoising = []

canvas = []

WHITE_LIST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-"

MIN_TEXT_SIZE = 10

THREAD_MAX_WORKER = os.cpu_count()

threadLock = threading.Lock()

ACCEPT_OVERLAY_AREA = 20

# endregion

'''

    @history    2018.05.25  Jeongwoo    Add pyqtSignal(recognizeLine, loadRecognitionResult)

'''

class Worker(QObject):

    from PyQt5.QtCore import QThread

    from PyQt5.QtCore import QTranslator

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

    from QtImageViewer import QtImageViewer

    import sys

    '''

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

        @history    humkyung 2018.06.08 add signal for progressbar

        @history    euisung 2018.11.27 add signal for unknown items

    '''

    finished = pyqtSignal()

    intReady = pyqtSignal(int)

    displayTitle = pyqtSignal(str)

    displayMessage = pyqtSignal(QListWidgetItem)

    updateProgress = pyqtSignal(int, str)

    updateBatchProgress = pyqtSignal(int, int)

    displayLog = pyqtSignal(MessageType, str)

    def __init__(self):

        super(Worker, self).__init__()

    '''

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

                    2018.05.28  Jeongwoo    Add Parameter 'xmlPath[0]'

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

                                            Change signal name (drawDetectedItems)

    '''

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

        try:

            if self.isSymbolChecked or self.isTrainingChecked:

                Worker.executeRecognition(self.createDetectedItems, self.path, self.listWidget, self.isLineChecked,

                                          self, self.batch, self.createUnknownItems)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

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

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

        except:

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

            sys.excepthook(_type, value, traceback)

        finally:

            self.finished.emit()

    '''

        @brief  remove small objects from given image

        @author humkyung

        @date   2018.04.26

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

    '''

    @staticmethod

    def remove_small_objects(image):

        try:

            app_doc_data = AppDocData.instance()

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

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

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

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

            # try to convert grayscale to binary

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

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

            selectedContours = []

            for contour in contours:

                area = cv2.contourArea(contour)

                if minArea < area < maxArea:

                    selectedContours.append(contour)

            # draw contour with white color

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

        except Exception as ex:

            from App import App

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

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

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

        return contourImage

    '''

        @brief  arrange line's position

        @author humkyung

        @date   2018.07.04

    '''

    @staticmethod

    def arrangeLinePosition(lines, symbols, listWidget):

        try:

            listWidget.addItem('Apply flow direction')

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

            visited = []

            visited.extend(pool)

            while len(pool) > 0:

                line = pool.pop()

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

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

                if rhs:

                    pool.extend(rhs)

                    visited.extend(rhs)

                    for item in rhs:

                        item.arrangeVertexOrder(line)

                # skip jointed symbols

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

                if symbolPool:

                    selected = []

                    visited.extend(symbolPool)

                    while len(symbolPool) > 0:

                        symbol = symbolPool.pop()

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

                        if rhs:

                            symbolPool.extend(rhs)

                            visited.extend(rhs)

                            selected.extend(rhs)

                        else:

                            selected.append(symbol)

                    # find lines which are connected last symbol

                    for symbol in selected:

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

                        if rhs:

                            pool.extend(rhs)

                            visited.extend(rhs)

                            for item in rhs:

                                item.arrangeVertexOrder(line)

                # up to here

            # up to here

        except Exception as ex:

            from App import App

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

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

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

    @staticmethod

    def executeRecognition(createDetectedItems, path, listWidget, isLineChecked, worker, batch, createUnknownItems):

        """

        @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

                    humkyung 2018.08.20 remove alreay existing symbol and text item before recognizing

                                        block until drawing reconized objects

                    euisung  2018.11.12 add title block properties

        """

        import re

        import timeit

        from TextDetector import TextDetector

        from Drawing import Drawing

        global ocrCompletedSrc

        global threadLock

        global searchedSymbolList

        global textInfoList

        global maxProgressValue

        try:

            app_doc_data = AppDocData.instance()

            drawings = app_doc_data.getDrawings()

            project = app_doc_data.getCurrentProject()

            textDetector = TextDetector()

            # remove already existing symbol and text

            if not batch:

                listWidget.addItem('Deleting existing items...')

                items = [item for item in worker.graphicsView.scene.items() if

                         type(item) is QEngineeringUnknownItem or type(item) is QEngineeringEndBreakItem or

                         type(item) is QEngineeringErrorItem or type(item) is QGraphicsBoundingBoxItem]

                if worker.isSymbolChecked:

                    items.extend(

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

                if worker.isTextChecked:

                    items.extend([item for item in worker.graphicsView.scene.items() if

                                  issubclass(type(item), QEngineeringTextItem)])

                for item in items:

                    item.transfer.onRemoved.emit(item)

            # up to here

            srcList = path

            Worker.initTargetSymbolDataList()

            for mainRes in srcList:

                ocrCompletedSrc = []

                searchedSymbolList = []

                textInfoList = []

                if not os.path.isfile(mainRes):

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

                    item.setBackground(Qt.red)

                    listWidget.addItem(item)

                    continue

                app_doc_data.clearItemList(True)

                app_doc_data.setImgFilePath(mainRes)

                app_doc_data.imgSrc = None

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

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

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

                # remove not drawing area

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

                for config in configs:

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

                    if len(found) == 4:

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

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

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

                for config in configs:

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

                    if len(found) == 4:

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

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

                noteArea = app_doc_data.getArea('Note')

                if noteArea is not None:

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

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

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

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

                # up to here

                area = app_doc_data.getArea('Drawing')

                if area is not None:

                    # copy image

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

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

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

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

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

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

                maxProgressValue = 0

                start_time = timeit.default_timer()

                listWidget.addItem(f"Start recognition{str(start_time)} : {mainRes}")

                threadLock.acquire()

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

                if worker.isSymbolChecked:

                    # calculate total count of symbol

                    for targetItem in targetSymbolList:

                        if type(targetItem) is list:

                            maxProgressValue += len(targetItem)

                        else:

                            maxProgressValue += 1

                    # up to here

                    maxProgressValue = maxProgressValue * 2

                threadLock.release()

                if worker.isSymbolChecked:

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

                    # detect equipments

                    pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                    for symbol in targetSymbolList[0]:

                        pool.submit(Worker.detectEquipmentOnPid, mainRes, symbol, listWidget, worker)

                    pool.shutdown(wait=True)

                    # up to here

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

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

                                           symbol for symbol in targetSymbolList[2]}

                        futures.wait(future_symbol)

                    if worker.isTrainingChecked:

                        import uuid

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

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

                        for item in searchedSymbolList:

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

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

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

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

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

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

                        continue

                    pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                    searchedTextSymList = []

                    for sym in searchedSymbolList:

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

                    pool.shutdown(wait=True)

                else:

                    '''

                    import math

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

                    for symbolItem in symbolItems:

                        symbolName = symbolItem.name

                        symbolType = symbolItem.type

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

                        sw = symbolItem.size[0] # check later

                        sh = symbolItem.size[1] # check later

                        symbolThreshold = 50 # not necessary

                        symbolMinMatchCount = 0 # not necessary

                        hitRate = 80 # not necessary

                        allowed_error = 0.0001

                        #degree 0

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

                            symbolRotatedAngle = 0

                        #degree 90

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

                            symbolRotatedAngle = 90

                        #degree 180

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

                            symbolRotatedAngle = 180

                        #degree 270

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

                            symbolRotatedAngle = 270

                        else:

                            symbolRotatedAngle = math.pi / 180 * symbolItem.angle

                        isDetectOnOrigin = 80 # not necessary

                        symbolRotateCount = 0 # not necessary

                        symbolOcrOption = 0 # not necessary

                        isContainChild = 0 # not necessary

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

                        symbolConnectionPoint = []

                        baseSymbol = str(symbolItem.parentSymbol)

                        additionalSymbol = str(symbolItem.childSymbol)

                        isExceptDetect = 0 # not necessary

                        detectFlip = symbolItem.flip

                        searchedSymbolList.append(Symbol(symbolName, symbolType , 

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

                            isDetectOnOrigin, symbolRotateCount, symbolOcrOption, isContainChild , 

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

                            [], 

                            baseSymbol, additionalSymbol, isExceptDetect, detectFlip))

                        worker.graphicsView.scene.removeItem(symbolItem)

                    pool = futures.ThreadPoolExecutor(max_workers = THREAD_MAX_WORKER)

                    '''

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

                    # appDocData.symbols.extend(symbolItems)

                    # appDocData.allItems.extend(symbolItems)

                    # for sym in searchedSymbolList:

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

                    # pool.shutdown(wait = True)

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

                area = app_doc_data.getArea('Drawing')

                if area is not None:

                    # copy area image

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

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

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

                otherTextInfoList = None

                titleBlockTextInfoList = None

                textInfoList = []

                if worker.isTextChecked:

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

                                                             offset)

                    if maxProgressValue < 2 * len(textAreas):

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

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

                        maxProgressValue = 2 * len(textAreas)

                    else:

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

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

                    textDetector.recognizeText(ocr_image, offset, textAreas, searchedSymbolList, worker,

                                               listWidget, maxProgressValue)

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

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

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

                    app_doc_data.activeDrawing.width, app_doc_data.activeDrawing.height = app_doc_data.imgSrc.shape[

                                                                                          ::-1]

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

                else:

                    import math

                    from TextInfo import TextInfo

                    textItems = [item for item in worker.graphicsView.scene.items() if

                                 issubclass(type(item), QEngineeringTextItem)]

                    app_doc_data.texts.extend(textItems)

                    app_doc_data.allItems.extend(textItems)

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

                    for lineNoTextItem in lineNoTextItems:

                        lineNoTextItem.set_property('Freeze', False)

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

                        lineNoTextItem.explode()

                    for textItem in textItems:

                        textInfoList.append(

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

                                     textItem.size[1], \

                                     round(math.degrees(textItem.angle))))

                        textItem.owner = None

                        worker.graphicsView.scene.removeItem(textItem)

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

                # check symbol validate

                valid_sym = []

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

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

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

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

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

                    valid_count = searchedTextSymList[index].getHasInstrumentLabel()

                    valid = 0

                    for text_info in textInfoList:

                        info_center = text_info.center

                        if info_center[0] > sym_xmin and info_center[0] < sym_xmax and info_center[1] > sym_ymin and \

                                info_center[1] < sym_ymax:

                            valid += 1

                            if valid >= valid_count:

                                valid_sym.append(searchedTextSymList[index])

                                break

                    if valid < valid_count:

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

                pool = futures.ThreadPoolExecutor(max_workers=THREAD_MAX_WORKER)

                for sym in valid_sym:

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

                pool.shutdown(wait=True)

                # up to here

                # remove text from image

                Worker.drawFoundSymbolsOnCanvas(mainRes, textInfoList, listWidget)

                textDetector.removeTextFromImage(app_doc_data.imgSrc, offset)

                if not worker.isTextChecked:

                    textInfoList.clear()

                # up to here

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

                cv2.imwrite(removedSymbolImgPath, app_doc_data.imgSrc)

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

                if area is not None:

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

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

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

                            app_doc_data.imgSrc)

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

                # get difference between original and recognized image

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

                Worker.getDifference(mainRes, foundFilePath)

                # up to here

                listWidget.addItem(worker.tr('Creating detected infos...'))

                worker.displayTitle.emit(worker.tr('Creating detected infos...'))

                createDetectedItems(searchedSymbolList, textInfoList,

                                    otherTextInfoList if otherTextInfoList is not None else [],

                                    titleBlockTextInfoList if titleBlockTextInfoList is not None else [])

                if isLineChecked:

                    Worker.recognizeLine(mainRes, listWidget, worker.graphicsView, worker, batch)

                else:

                    lineItems = [item for item in worker.graphicsView.scene.items()

                                 if issubclass(type(item), QEngineeringLineItem)]

                    app_doc_data.lines.extend(lineItems)

                    app_doc_data.allItems.extend(lineItems)

                    for lineItem in lineItems:

                        lineItem.owner = None

                        for conn in lineItem.connectors:

                            conn.connectedItem = None

                        worker.graphicsView.scene.removeItem(lineItem)

                # connect symbol to symbol

                try:

                    configs = app_doc_data.getConfigs('Line Detector', 'Length to connect line')

                    toler = int(configs[0].value) if configs else 20

                    for symbol in app_doc_data.symbols:

                        matches = [it for it in app_doc_data.symbols if

                                   it is not symbol and symbol.is_connectable(it, toler=toler)]

                        for match in matches:

                            symbol.connect_if_possible(match)

                except Exception as ex:

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

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

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

                # up to here

                listWidget.addItem('Connecting lines')

                area = app_doc_data.getArea('Drawing')

                detector = LineDetector(area.img)

                symbols = app_doc_data.symbols

                configs = app_doc_data.getConfigs('Line Detector', 'Length to connect line')

                toler = int(configs[0].value) if configs else 20

                if app_doc_data.lines:

                    # connect line to symbol

                    try:

                        for line in app_doc_data.lines:

                            matches = [symbol for symbol in symbols if symbol.is_connectable(line, toler=toler)]

                            for symbol in matches:

                                detector.connectLineToSymbol(line, symbol, toler=toler)

                    except Exception as ex:

                        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[

                            -1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

                    # up to here

                    # connect line to line

                    try:

                        for line in app_doc_data.lines:

                            matches = [it for it in app_doc_data.lines if

                                       (it is not line) and (not line.isParallel(it))]

                            for match in matches:

                                detector.connectLineToLine(match, line, toler)

                        # change line type using symbol connection type(info)

                        for sym in symbols:

                            if sym.conn_type:

                                for index in range(len(sym.conn_type)):

                                    item = sym.connectors[index].connectedItem

                                    if item and type(item) is QEngineeringLineItem:

                                        Worker.changeConnectedLineType(item, sym.conn_type[index])

                    except Exception as ex:

                        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[

                            -1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno)

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

                    # up to here

                createUnknownItems(mainRes)

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

        except Exception as ex:

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

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

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

        finally:

            pass

    @staticmethod

    def changeConnectedLineType(line, lineType):

        line.lineType = lineType

        if type(line.connectors[0].connectedItem) is QEngineeringLineItem and \

                (line.connectors[0].connectedItem.connectors[0].connectedItem is line or

                 line.connectors[0].connectedItem.connectors[1].connectedItem is line) and \

                line.connectors[0].connectedItem.lineType is not lineType:

            Worker.changeConnectedLineType(line.connectors[0].connectedItem, lineType)

        if type(line.connectors[1].connectedItem) is QEngineeringLineItem and \

                (line.connectors[1].connectedItem.connectors[0].connectedItem is line or

                 line.connectors[1].connectedItem.connectors[1].connectedItem is line) and \

                line.connectors[1].connectedItem.lineType is not lineType:

            Worker.changeConnectedLineType(line.connectors[1].connectedItem, lineType)

    '''

        @history    2018.05.25  Jeongwoo    Moved from MainWindow

                    2018.05.28  Jeongwoo    Add xmlPath Parameter and append LineInfo into xml

                    2018.05.29  Jeongwoo    Change method to add item

                    2018.05.30  Jeongwoo    Remove parameter (xmlPath)

                    humkyung 2018.06.11 add drawing path to parameter and write recognized lines to image

                    humkyung 2018.07.04 call arrangeLinePosition after creating line

    '''

    @staticmethod

    def recognizeLine(path, listWidget, graphicsView, worker, batch):

        from shapely.geometry import Point, LineString

        from SymbolSvgItem import SymbolSvgItem

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        from EngineeringTextItem import QEngineeringTextItem

        from EngineeringLineItem import QEngineeringLineItem

        from LineDetector import LineDetector

        try:

            listWidget.addItem('Starting line recognition')

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

            app_doc_data = AppDocData.instance()

            project = app_doc_data.getCurrentProject()

            # remove already existing line and flow arrow item

            if not batch:

                items = [item for item in worker.graphicsView.scene.items() if (type(item) is QEngineeringLineItem)]

                for item in items:

                    item.transfer.onRemoved.emit(item)

            # up to here

            # detect line

            connectedLines = []

            area = app_doc_data.getArea('Drawing')

            area.img = worker.remove_small_objects(area.img)

            detector = LineDetector(area.img)

            symbols = []

            for item in app_doc_data.symbols:

                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)

            # line detection without symbol connection point info

            configs = app_doc_data.getConfigs('Line', 'Diagonal')

            if configs and int(configs[0].value) is 1:

                remainLines = detector.detectLineWithoutSymbol()

                windowSize = app_doc_data.getSlidingWindowSize()

                thickness = int(windowSize[1])

                for line in remainLines:

                    line.append(thickness)

                connectedLines.extend(remainLines)

            configs = app_doc_data.getConfigs('Line Detector', 'Length to connect line')

            toler = int(configs[0].value) if configs else 20

            detector.mergeLines(connectedLines, toler=toler)

            for pts in connectedLines:

                line = QEngineeringLineItem(

                    vertices=[(area.x + param[0], area.y + param[1]) for param in pts[:-1]], thickness=pts[2])

                line.area = 'Drawing'

                app_doc_data.lines.append(line)

                app_doc_data.allItems.append(line)

        except Exception as ex:

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

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

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

        finally:

            listWidget.addItem('Finishing line recognition')

            worker.finished.emit()

    '''

        @history    2018.04.24  Jeongwoo    Add isExceptDetect Field

                    2018.05.09  Jeongwoo    Add targetSymbolList clear

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

    '''

    @staticmethod

    def initTargetSymbolDataList():

        global targetSymbolList

        targetSymbolList.clear()

        appDocData = AppDocData.instance()

        symbolList = appDocData.getTargetSymbolList()

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

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

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

        targetSymbolList.append(equipments)

        targetSymbolList.append(nozzles)

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

        return targetSymbolList

    '''

        @brief  detect equipment

        @author humkyung

        @date   2018.07.07

    '''

    @staticmethod

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

        try:

            equipments = Worker.detectSymbolOnPid(mainRes, targetSymbol, listWidget, worker)

            for equipment in equipments:

                # detect nozzles around equimpent

                for nozzle in targetSymbolList[1]:

                    Worker.detectNozzleOnPid(equipment, nozzle, listWidget, worker)

                # up to here

        except Exception as ex:

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

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

            worker.displayLog(MessageType.Error, message)

    '''

        @brief      detect symbol on PID

        @author     jwkim

        @date   

        @history    humkyung 2018.04.06 check if symbol file exists

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

                                        Change parameter on add symbol part (mpCount → hitRate)

                                        Remove unusing calculation (avg)

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

                    humkyung 2018.07.07 return searched symbols

    '''

    @staticmethod

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

        import copy

        global ocrCompletedSrc

        global threadLock

        global maxProgressValue

        try:

            forTraining = worker.isTrainingChecked

            symbolName = targetSymbol.getName()

            symbolType = targetSymbol.getType()

            symbolPath = targetSymbol.getPath()

            symbolThreshold = targetSymbol.getThreshold()  # if not forTraining else targetSymbol.getThreshold() / 3 * 2

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

            detectFlip = targetSymbol.getDetectFlip()

            hasInstrumentLabel = targetSymbol.getHasInstrumentLabel()

            # check if symbol file is target or not

            if isExceptDetect == 1:

                item = QListWidgetItem('{} file is not target'.format(symbolName))

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

                item.setBackground(QColor('red'))

                listWidget.addItem(item)

                return

            # up to here

            sym = cv2.imread(symbolPath, 1)

            symGray = Worker.cvtGrayImage(sym)

            symGrayOri = copy.copy(symGray)

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

            app_doc_data = AppDocData.instance()

            area = app_doc_data.getArea('Drawing')

            if area is not None:

                roiItem = area.img.copy() if hasInstrumentLabel else area.img

                offsetDrawingArea.append(area.x)

                offsetDrawingArea.append(area.y)

            else:

                offsetDrawingArea.append(0)

                offsetDrawingArea.append(0)

                if isDetectOnOrigin == 1:

                    roiItem = app_doc_data.imgSrc

                else:

                    roiItem = ocrCompletedSrc

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

            roiItemSp = (0, 0)

            roiItemEp = (srcWidth, srcHeight)

            # when text is located inside of symbol

            if area is not None and hasInstrumentLabel:

                # remove objects smaller than symbol

                selected_contours = []

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

                index = 0

                for contour in contours:

                    child, parent = hierarchy[0][index][2], hierarchy[0][index][3]

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

                    if w * h < sow * soh * 0.5:

                        contour_area = cv2.contourArea(contour, True)

                        if contour_area > 0:

                            selected_contours.append(contour)

                    index += 1

                # up to here

                # draw contour with white color

                roiItem = cv2.drawContours(roiItem, selected_contours, -1, (255, 255, 255), -1)

            # try to recognize symbol twice(first one is normal, second on is flipped)

            steps = [False, True] if detectFlip else [False]

            for flipped in steps:

                if flipped:

                    symGray = symGrayOri

                    symGray = cv2.flip(symGray, 1)

                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 = Worker.getRotatedChildInfo(additionalSymbol)

                        continue

                    # get Rotated Original Point

                    originalPoint = Worker.getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint,

                                                                      symbolRotatedAngle, sw, sh, sow, soh, flipped)

                    connectionPoint = Worker.getCalculatedConnectionPoint(symbolConnectionPoint, symbolRotatedAngle, sw,

                                                                          sh, sow, soh, flipped)

                    # For OPC

                    drawing_area = app_doc_data.getArea('Drawing')

                    if drawing_area is not None and (symbolType == "Piping OPC\'s" or symbolType == "Instrument OPC\'s"):

                        worker.detectOPCOnPid(drawing_area, symGray)

                    # Template Matching

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

                    loc = np.where(tmRes >= symbolThreshold)

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

                        mpCount = 0  # Match Point Count

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

                        if symbolMinMatchCount > 0:

                            mpCount = Worker.getMatchPointCount(roi, symGray)

                            if not (mpCount >= symbolMinMatchCount):

                                continue

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

                                          roiItemSp[1] + pt[1] + round(offsetDrawingArea[1]))

                        # print(searchedItemSp)

                        overlapArea = 0

                        symbolIndex = -1

                        for i in range(len(searchedSymbolList) - 1, -1, -1):

                            area = Worker.contains(searchedSymbolList[i], searchedItemSp, sw, sh)

                            if area > ACCEPT_OVERLAY_AREA:

                                # if area > overlapArea:

                                #    overlapArea = area

                                #    symbolIndex = i

                                overlapArea = area

                                symbolIndex = i

                                break

                                """

                                categories = [appDocData.isEquipmentType(symbolType), appDocData.isEquipmentType(searchedSymbolList[i].getType())]

                                if categories[0] == categories[1]:

                                    symbolIndex = i

                                    break

                                """

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

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

                        if overlapArea <= ACCEPT_OVERLAY_AREA:

                            threadLock.acquire()

                            foundSymbolCount = foundSymbolCount + 1

                            Worker.addSearchedSymbol(symbolName, symbolType,

                                                     searchedItemSp, sw, sh, symbolThreshold, symbolMinMatchCount,

                                                     hitRate, symbolRotatedAngle,

                                                     isDetectOnOrigin, symbolRotateCount, symbolOcrOption,

                                                     isContainChild,

                                                     originalPoint, connectionPoint, baseSymbol, additionalSymbol,

                                                     isExceptDetect,

                                                     detectFlip=1 if flipped else 0,

                                                     hasInstrumentLabel=hasInstrumentLabel)

                            threadLock.release()

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

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

                                searchedSymbol = searchedSymbolList[symbolIndex]

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

                                if symbolName == searchedSymbol.getName():

                                    symbolHitRate = searchedSymbol.getHitRate()

                                    if symbolHitRate - searchedSymbol.getThreshold() < hitRate - symbolThreshold:

                                        threadLock.acquire()

                                        # replace existing symbol with new symbol has high accuracy

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

                                                                                        searchedItemSp, sw, sh,

                                                                                        symbolThreshold,

                                                                                        symbolMinMatchCount, hitRate,

                                                                                        symbolRotatedAngle,

                                                                                        isDetectOnOrigin,

                                                                                        symbolRotateCount,

                                                                                        symbolOcrOption, isContainChild,

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

                                                                                                 originalPoint),

                                                                                        '/'.join('{},{},{},{}'.format(

                                                                                            param[0], param[1],

                                                                                            param[2], param[3]) for

                                                                                                 param in

                                                                                                 connectionPoint),

                                                                                        baseSymbol, additionalSymbol,

                                                                                        isExceptDetect,

                                                                                        detectFlip=1 if flipped else 0,

                                                                                        hasInstrumentLabel=hasInstrumentLabel)

                                        threadLock.release()

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

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

                                    if searchedSymbol.area > sw * sh * 10:  # searched equipment area is greather than 10 times of symbol's area

                                        threadLock.acquire()

                                        foundSymbolCount = foundSymbolCount + 1

                                        Worker.addSearchedSymbol(symbolName, symbolType,

                                                                 searchedItemSp, sw, sh, symbolThreshold, hitRate,

                                                                 hitRate, symbolRotatedAngle,

                                                                 isDetectOnOrigin, symbolRotateCount, symbolOcrOption,

                                                                 isContainChild,

                                                                 originalPoint, connectionPoint, baseSymbol,

                                                                 additionalSymbol, isExceptDetect,

                                                                 detectFlip=1 if flipped else 0,

                                                                 hasInstrumentLabel=hasInstrumentLabel)

                                        threadLock.release()

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

                                elif not forTraining:

                                    searchedSymbol = searchedSymbolList[symbolIndex]

                                    symbolHitRate = searchedSymbol.getHitRate()

                                    if symbolHitRate - searchedSymbol.getThreshold() < hitRate - symbolThreshold:

                                        threadLock.acquire()

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

                                                                                        searchedItemSp, sw, sh,

                                                                                        symbolThreshold,

                                                                                        symbolMinMatchCount, hitRate,

                                                                                        symbolRotatedAngle,

                                                                                        isDetectOnOrigin,

                                                                                        symbolRotateCount,

                                                                                        symbolOcrOption, isContainChild,

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

                                                                                                 originalPoint),

                                                                                        '/'.join('{},{},{},{}'.format(

                                                                                            param[0], param[1],

                                                                                            param[2], param[3]) for

                                                                                                 param in

                                                                                                 connectionPoint),

                                                                                        baseSymbol, additionalSymbol,

                                                                                        isExceptDetect,

                                                                                        detectFlip=1 if flipped else 0,

                                                                                        hasInstrumentLabel=hasInstrumentLabel)

                                        threadLock.release()

                                # 학습용 데이터 생성을 위해 교체하지 않고 추가함

                                elif forTraining:

                                    threadLock.acquire()

                                    foundSymbolCount = foundSymbolCount + 1

                                    Worker.addSearchedSymbol(symbolName, symbolType,

                                                             searchedItemSp, sw, sh, symbolThreshold,

                                                             symbolMinMatchCount, hitRate, symbolRotatedAngle,

                                                             isDetectOnOrigin, symbolRotateCount, symbolOcrOption,

                                                             isContainChild,

                                                             originalPoint, connectionPoint, baseSymbol,

                                                             additionalSymbol, isExceptDetect,

                                                             detectFlip=1 if flipped else 0,

                                                             hasInstrumentLabel=hasInstrumentLabel)

                                    threadLock.release()

                    # Rotate Symbol

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

                    symbolRotatedAngle = symbolRotatedAngle + 90

                    if additionalSymbol is not None:

                        additionalSymbol = Worker.getRotatedChildInfo(additionalSymbol)

            threadLock.acquire()

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

                foundSymbolCount) + ')')

            threadLock.release()

            """

            if area is not None and hasInstrumentLabel:

                # restore objects smaller than symbol

                roiItem = cv2.drawContours(roiItem, outside_contours, -1, (0, 0, 0), -1)

                roiItem = cv2.drawContours(roiItem, hole_contours, -1, (255, 255, 255), -1)

                # up to here

                cv2.imwrite('c:\\Temp\\contour2.png', roiItem)

            """

            worker.updateProgress.emit(maxProgressValue, symbolPath)

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

        except Exception as ex:

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

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

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

        return []

    @staticmethod

    def detectOPCOnPid(area, symGray):

        results = []

        # try:

        #     symbol = cv2.copyMakeBorder(symGray, 1, 1, 1, 1, cv2.BORDER_CONSTANT, value=255)

        #     not_symbol = cv2.bitwise_not(symbol)

        #     symbol_contours, symbol_hierachy = cv2.findContours(not_symbol, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        #     if symbol_hierachy[0][0][0] != -1:

        #         return results

        #

        #     contour_count = len(symbol_contours)

        #     for i in range(1, contour_count):

        #         symbol_area = cv2.contourArea(symbol_contours[i])

        #

        #         for contour in area.contours:

        #             area_area = cv2.contourArea(contour)

        #             if area_area * 1.2 >= symbol_area >= area_area * 0.8:

        #                 I1 = cv2.matchShapes(symbol_contours[i], contour, 1, 0)

        #                 I2 = cv2.matchShapes(symbol_contours[i], contour, 2, 0)

        #                 I3 = cv2.matchShapes(symbol_contours[i], contour, 3, 0)

        #                 if I1 < 1 and I2 < 1 and I3 < 0.1:

        #                     rect = cv2.boundingRect(contour)

        #                     results.append([0.8, [rect[0],rect[1]]])

        #         break

        # except Exception as ex:

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

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

        #     a = 5

        return results

    '''

        @brief      detect nozzle

        @author     humkyung

        @date       2018.07.07

        @history    humkyhung 2018.07.17 pass equpment as parameter instead of image

    '''

    @staticmethod

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

        global src

        global threadLock

        global maxProgressValue

        try:

            symbolName = nozzle.getName()

            symbolType = nozzle.getType()

            symbolPath = nozzle.getPath()

            symbolThreshold = nozzle.getThreshold()

            symbolMinMatchCount = nozzle.getMinMatchCount()

            isDetectOnOrigin = nozzle.getIsDetectOnOrigin()

            symbolRotateCount = nozzle.getRotationCount()

            symbolOcrOption = nozzle.getOcrOption()

            isContainChild = nozzle.getIsContainChild()

            symbolOriginalPoint = nozzle.getOriginalPoint()

            symbolConnectionPoint = nozzle.getConnectionPoint()

            baseSymbol = nozzle.getBaseSymbol()

            additionalSymbol = nozzle.getAdditionalSymbol()

            isExceptDetect = nozzle.getIsExceptDetect()

            foundSymbolCount = 0

            # check if symbol file exists

            if not os.path.isfile(symbolPath):

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

                item.setBackground(QColor('red'))

                listWidget.addItem(item)

                return

            # up to here

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

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

            # get image of equipment with offset of nozzle size

            appDocData = AppDocData.instance()

            pt = equipment.getSp()

            nozzleSize = max(sow, soh)

            sx = round(pt[0]) - nozzleSize

            sy = round(pt[1]) - nozzleSize

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

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

            offset = (sx, sy)

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

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

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

            # up to here

            roiItemSp = (0, 0)

            roiItemEp = (srcWidth, srcHeight)

            roiItem = img

            symbolAngle = 0

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

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

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

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

                # get Rotated Original Point

                originalPoint = Worker.getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint, symbolAngle,

                                                                  sw, sh, sow, soh)

                connectionPoint = Worker.getCalculatedConnectionPoint(symbolConnectionPoint, symbolAngle, sw, sh, sow,

                                                                      soh)

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