HYTOS

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

class AreaZoomCommand(AbstractCommand.AbstractCommand):

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    '''

        @history    2018.06.27  Jeongwoo    Add variables [startPoint, endPoint]

    '''

    def __init__(self, imageViewer):

        super(AreaZoomCommand, self).__init__(imageViewer)

        self.imageViewer.setCursor(QCursor(Qt.CrossCursor))

        self._rubberBand = QRubberBand(QRubberBand.Rectangle, self.imageViewer)

        self._origin = QPoint()

        self.isLeftClicked = False

    '''

        @brief      pan image by left click and drag

        @history    2018.06.27  Jeongwoo    Add if-statement for panning after zoom in / Add variable [startPoint, endPoint]

                    humkyung 2018.08.29 use rubberband to select area

    '''

    def execute(self, param):

        event = param[1]

        scenePos = param[2]

        self.isTreated = False

        if 'mousePressEvent' == param[0]:

            if event.button() == Qt.LeftButton:

                    self._origin = event.pos()

                    self._rubberBand.setGeometry(QRect(self._origin, QSize()))

                    self._rubberBand.show()

                self.imageViewer.leftMouseButtonPressed.emit(scenePos.x(), scenePos.y())

        elif 'mouseMoveEvent' == param[0] and event.buttons() == Qt.LeftButton:

            if self._rubberBand.isVisible():

                    self._rubberBand.hide()

                    topLeft = self.imageViewer.mapToScene(self._rubberBand.geometry().topLeft())

                    bottomRight = self.imageViewer.mapToScene(self._rubberBand.geometry().bottomRight())

                        self.onRejected.emit(self)

            finally:

                pass

    def redo(self):

        pass

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

class HighlightCommand(AbstractCommand.AbstractCommand):

    onSuccess = pyqtSignal(float, float, float, float)

    def __init__(self, imageViewer):

        super(HighlightCommand, self).__init__(imageViewer)

    '''

        @brief  highlight items selected by user

    '''

    def execute(self, param):

        from EngineeringRunItem import QEngineeringRunItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        self.isTreated = False

        if param is not None:

            if type(param) is QEngineeringRunItem:

                rect = None

                if rect is not None:

                    self.imageViewer.centerOn(rect.center())

                    for item in param.items:

                        item.setSelected(True)

                if rect is not None:

                    self.imageViewer.centerOn(rect.center())

                    for item in param:

                        if item.symbol:

            else:

                rect = param.sceneBoundingRect()

                self.imageViewer.centerOn(rect.center())

                param.setSelected(True)

                param.update()

                if type(param) is QEngineeringLineNoTextItem:

                    for run in param.runs:

                        for item in run.items:

        pass

    def redo(self):

from AppDocData import AppDocData

from Drawing import Drawing

class CustomTreeWidgetItem(QTreeWidgetItem):

    def __init__(self, *args, **kwargs):

        super(CustomTreeWidgetItem, self).__init__(*args, **kwargs)

        super(CustomTreeWidgetItem, self).setData(column, role, value)

class QItemTreeWidget(QTreeWidget):

    """ This is item tree widget """

    TREE_DATA_ROLE = Qt.UserRole

    singleClicked = pyqtSignal(SymbolSvgItem)

    noteNoSingleClicked = pyqtSignal(str, dict)

    lineNoSingleClicked = pyqtSignal(QEngineeringAbstractItem)

    '''

        @history    2018.05.11  Jeongwoo    Add Context Menu settings

    '''

    def __init__(self, imageViewer):

        QTreeWidget.__init__(self)

        @author     humkyung

        @date       2018.07.20

    '''

    def keyPressEvent(self, event):

        try:

            if event.key() == Qt.Key_Delete:

                        data = item.data(0, self.TREE_DATA_ROLE)

                        if data is not None:

                            data.transfer.onRemoved.emit(data)

                            #    self.imageViewer.mainWindow.removedItems['LINE'].append(str(data.uid))

                            #    self.imageViewer.mainWindow.removedItems['INST'].append(str(data.uid))

                            #    self.imageViewer.mainWindow.removedItems['EQUIP'].append(str(data.uid))

                            #    self.imageViewer.mainWindow.removedItems['NOTE'].append(str(data.uid))

                event.accept()

            elif event.key() == Qt.Key_Up:

                if self.selectedItems():

            else:

                event.ignore()

        except Exception as ex:

    '''

        @brief      Show Context Menu

        @author     Jeongwoo

        @history    18.06.14    Jeongwoo    Add item None check

                    humkyung 2018.06.27 add menu of run item for selecting line type

    '''

    def openContextMenu(self, position):

        from EngineeringRunItem import QEngineeringRunItem

            if item is self.LineNoTreeItem:

                menu = QMenu()

                explode_action = QAction(self.tr("Explode"))

                menu.addAction(explode_action)

                explodeKeepFromTo_action = QAction(self.tr("Explode (keep from, to)"))

                menu.addAction(explodeKeepFromTo_action)

                menu.exec_(self.viewport().mapToGlobal(position))

            else:

                if len(indexes) > 0 and data is not None and issubclass(type(data), QEngineeringLineNoTextItem):

                    menu = QMenu()

                    pickColorAction = QAction(self.tr("Select Line Color"))

                    menu.addAction(pickColorAction)

                    explode_action = QAction(self.tr("Explode"))

                    freeze = data.prop('Freeze')

                    explode_action.setEnabled(not freeze)

                    menu.addAction(explode_action)

                    if type(data) is QEngineeringLineNoTextItem:

                        explodeKeepFromTo_action = QAction(self.tr("Explode (keep from, to)"))

                        explodeKeepFromTo_action.setEnabled(not freeze)

                        menu.addAction(explodeKeepFromTo_action)

                    reverse_flow_action = QAction(self.tr("Reverse Flow"))

                    menu.addAction(reverse_flow_action)

                    menu.exec_(self.viewport().mapToGlobal(position))

                elif len(indexes) > 0 and data is not None and issubclass(type(data), QEngineeringRunItem):

                    menu = QMenu()

                    lineTypeAction = QAction(self.tr("Select Line Type"))

                    menu.addAction(lineTypeAction)

                    line_no = item.parent().data(0, self.TREE_DATA_ROLE)

                    freeze = line_no.prop('Freeze')

                    explode_action = QAction(self.tr("Explode"))

                    explode_action.setEnabled(not freeze)

                    menu.addAction(explode_action)

                    reverse_flow_action = QAction(self.tr("Reverse Flow"))

                    menu.addAction(reverse_flow_action)

                    menu.exec_(self.viewport().mapToGlobal(position))

            self.SymbolsTreeItem.sortChildren(0, Qt.AscendingOrder)

    '''

        @brief      Pick Color for Line No

        @date       18.05.11

        @history    18.05.14    Jeongwoo    Change method to change color by changeTreeWidgetItemColorRecursively()

    '''

    def pickColorClickEvent(self, lineNoTreeWidgetItem):

        if color is not None:

            lineNoTreeWidgetItem.setForeground(0, QBrush(color))

            lineNoTreeWidgetItem.setFont(0, lineNoTreeWidgetItem.font(0))

        from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

        for i in reversed(range(self.LineNoTreeItem.childCount())):

    def reverse_line_flow(self, lineTreeWidgetItem):

        """ reverse line flow """

        @author     humkyung 

        @date       2018.06.27

    '''

    def lineTypeClickEvent(self, item):

        pass

        @author     Jeongwoo

        @date       18.05.14

    '''

    def changeTreeWidgetItemColorRecursively(self, item, color):

        for index in range(item.childCount()):

            child = item.child(index)

                    2018.05.09  Jeongwoo    Change method to add default tree items

                    humkyung 2018.06.10 add tree item for Line No and Unknown Item

    '''

    def setCurrentPID(self, drawingName):

        appDocData = AppDocData.instance()

        @date   2018.05.15

        @history    2018.05.17  Jeongwoo    Change run item color with parent(LineNo Item) color

    '''

    def addPipeRunTreeItemIfNeed(self, lineNoTreeItem, pipeRun):

        for index in range(lineNoTreeItem.childCount()):

            treeItem = lineNoTreeItem.child(index)

            if itemData is not None and itemData == pipeRun:

                return treeItem

        runItem.setData(0, self.TREE_DATA_ROLE, pipeRun)

        brush = lineNoTreeItem.foreground(0)

                    humkyung 2018.06.12 add unknown item

                    humkyung 2018.07.20 append nozzle to equipment

    '''

    def addTreeItem(self, parent, child):

        item = None

        appDocData = AppDocData.instance()

                    if isEquipmentType:

                        item = QTreeWidgetItem(self.EqpTreeItem, [child.name])

                        item.setData(0, self.TREE_DATA_ROLE, child)

                        if item is None:

                            item = QTreeWidgetItem(self.SymbolsTreeItem, [child.name])

                    elif child.type == 'Notes':

                        return item

                    else:

                        item = QTreeWidgetItem(self.SymbolsTreeItem, [child.name])

                    if item is not None:

                        item.setIcon(0, QIcon(iconPath))

                        item.setData(0, self.TREE_DATA_ROLE, child)

                        brush = QBrush()

                            self.SymbolsTreeItem.sortChildren(0, Qt.AscendingOrder)  # sort childrens

                elif type(child) is QEngineeringLineNoTextItem:

                    for index in range(self.LineNoTreeItem.childCount()):

                            self.LineNoTreeItem.takeChild(index)

                            break

                    item = CustomTreeWidgetItem([child.text().replace('\n', '')])

                    # show note icon if note icon is setted

                    if child.symbol:

                        item.setIcon(0, QIcon(iconPath))

                elif (type(child) is QEngineeringUnknownItem):

                    item = QTreeWidgetItem(['Unknown'])

                    if child.lineIndicator == 'Match':

                        item.setHidden(True)

            elif issubclass(type(child), SymbolSvgItem):  # change item's parent

                if foundItems is not None:

                    for item in foundItems:

                        data = item.data(0, self.TREE_DATA_ROLE)

                                for index in range(len(parentData.runs)):

                                    runGroup = parentData.runs[index]

                                    if data in runGroup.items:

                                        brush = QBrush()

                                        brush.setColor(QColor(item.data(0, self.TREE_DATA_ROLE).getColor()))

                                        item.setForeground(0, brush)

                                        item.setFont(0, item.font(0))

                                        runItem.addChild(item)

                                        break

                                    else:

                                        pass

                            elif parent is not None:

                                parent.addChild(item)

                            break

            elif type(child) is QEngineeringLineNoTextItem:

                if foundItems is not None:

                    for item in foundItems:

                        data = item.data(0, self.TREE_DATA_ROLE)

            from App import App

            from AppDocData import MessageType

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

        return item

                    humkyung 2018.07.20 put items which's owner is None before item which's owner is not None

    '''

    lastSceneItems = None

    def sceneChanged(self, sceneItems):

        try:

            first = [item for item in changedSceneItems if item.owner is None]

            second = [item for item in changedSceneItems if item.owner is not None]

            if first + second: self.initResultTreeWidget(first + second)

                    2018.04.25 Jeongwoo     Add QEngineeringNoteItem Child

                    2018.04.26 Jeongwoo     Change method to insert child

    '''

    def initResultTreeWidget(self, items):

        for item in items:

            if (type(item) is QEngineeringNoteItem):

                self.addTreeItem(self.NotesTreeItem, item)

            else:

                self.addTreeItem(self.root, item)

        if self.NotesTreeItem is not None:

            self.NotesTreeItem.sortChildren(0, Qt.AscendingOrder)

        self.expandAll()

    def itemCheckBoxToggled(self, item, checkState):

        """

        set visible of invisible of item

        """

        try:

            if (type(itemData) is QEngineeringLineNoTextItem) or (type(itemData) is QEngineeringTrimLineNoTextItem):

                itemData.setVisible(checkState == Qt.CheckState.Checked)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

        finally:

            pass

                    18.05.10    Jeongwoo    Add lineNoSingleClicked emit

                    humkyung 2018.07.07 emit singleClicked signal when user click drawing name

    '''

        from Drawing import Drawing

        from EngineeringRunItem import QEngineeringRunItem

        from HighlightCommand import HighlightCommand

        hilightColor = QColor(255, 0, 0, 127)

        itemData = item.data(0, self.TREE_DATA_ROLE)

            if issubclass(type(itemData), SymbolSvgItem):

                HighlightCommand(self.imageViewer).execute(itemData)

                ## Draw rectangle on selected symbol

                #    self.imageViewer.centerOn(rect.center())

                ## Send new event to imageViewer's zoomImage Method

            elif type(itemData) is QEngineeringRunItem:

                HighlightCommand(self.imageViewer).execute(itemData)

                self.lineNoSingleClicked.emit(itemData)

                    item.child(child).setSelected(True)

            elif type(itemData) is QEngineeringLineNoTextItem:

                HighlightCommand(self.imageViewer).execute(itemData)

                itemData.setSelected(True)

                #    for cchild in range(item.child(child).childCount()):

                #        item.child(child).child(cchild).setSelected(True)

            elif type(itemData) is list and type(itemData[0]) is QEngineeringNoteItem:

                HighlightCommand(self.imageViewer).execute(itemData)

            elif type(itemData) is Drawing:

                self.drawingClicked.emit(itemData)

            '''

            if issubclass(type(itemData), QGraphicsItem):

                itemData.setSelected(True)

        @history    2018.06.18  Jeongwoo    Add if-statement for QEngineeringUnknownItem

        @history    2018.11.22  euisung     add delete note

    '''

    def findItemByData(self, item):

        if issubclass(type(item), SymbolSvgItem):

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringLineNoTextItem:

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringUnknownItem:

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringNoteItem:

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        elif type(item) is QEngineeringTrimLineNoTextItem:

            for foundItem in foundItems:

                data = foundItem.data(0, self.TREE_DATA_ROLE)

                if data is not None and data is item:

                    return foundItem

        return None

    '''

        @author kyouho

        @date   2018.09.17

    '''

    def InitLineNoItems(self):

            removeLineItem = []

            for lineIndex in range(self.LineNoTreeItem.childCount()):

                ## LineNoItem, TrimLine Item

            from App import App

            from AppDocData import MessageType

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

    '''

                                            Declare self.TREE_DATA_ROLE for QTreeWidgetItem.data(column, role)

        @history    2018.11.22  euisung     add note, unknown

    '''

    @pyqtSlot(SymbolSvgItem)

    def findItem(self, item):

        if issubclass(type(item), SymbolSvgItem):

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                        self.setCurrentItem(fItem)

                        return

        elif type(item) is QEngineeringLineNoTextItem:

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                    self.setCurrentItem(child)

                    return

        elif type(item) is QEngineeringUnknownItem:

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                        self.setCurrentItem(fItem)

                        return

        elif type(item) is QEngineeringTrimLineNoTextItem:

            if foundItems is not None:

                for fItem in foundItems:

                    data = fItem.data(0, self.TREE_DATA_ROLE)

                        return

        ## Not found

    '''

        @brief      remove given item

        @author     humkyung

        @history    Jeongwoo 2018.05.25 Remove Highlighting when item removed

                    humkyung 2018.07.22 removed code to Remove highlighting

    '''

    @pyqtSlot(QGraphicsItem)

    def itemRemoved(self, item):

        try:

        if hasattr(self, 'NotesTreeItem'):

            self.NotesTreeItem.setText(0, 'NOTES({})'.format(self.NotesTreeItem.childCount()))

        if hasattr(self, 'UnknownTreeItem'):

            self.onCommandRejected()

            dialog = QTextDataListDialog(self)

            dialog.show()

        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)

    '''

    def updateViewer(self, zoomNewRect=None):

        if not self.hasImage():

            return

        else:

    def zoomImageInit(self):

        if self.hasImage():

        """Zoom in & out """

        HALF_SIZE = 300

        if isZoomIn:

            self.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

        else:

            zoomNewRect = None

            self.updateViewer(zoomNewRect)

    '''

        @brief  mouse move event

    '''

            from AppDocData import MessageType

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

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

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

        except:

            from App import App

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

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

        return contourImage

            from App import App

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

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

    @staticmethod

            # remove already existing symbol and text

            if not batch:

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

                if worker.isSymbolChecked:

                    items.extend(

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

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

                             type(item) is QGraphicsBoundingBoxItem]:

                    item.transfer.onRemoved.emit(item)

            # up to here

            srcList = path

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

                            continue

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

                    pool.shutdown(wait=True)

                else:

                    '''

                    import math

                    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.imgName = os.path.splitext(os.path.basename(mainRes))[0]

                else:

                        lineNoTextItem.explode()

                    for textItem in textItems:

                        textItem.owner = None

                        worker.graphicsView.scene.removeItem(textItem)

                    valid = 0

                    for text_info in textInfoList:

                        info_center = text_info.center

                            valid += 1

                            if valid >= valid_count:

                                valid_sym.append(searchedTextSymList[index])

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

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

                    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:

                        # print(str(symbol))

                        # print(matches)

                        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,

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

                # up to here

                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,

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

        finally:

            pass

    def changeConnectedLineType(line, lineType):

        line.lineType = lineType

        if type(line.connectors[0].connectedItem) is QEngineeringLineItem 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.lineType is not lineType:

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

                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,

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

        finally:

            listWidget.addItem('Finishing line recognition')

                # up to here

        except Exception as ex:

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

            worker.displayLog(MessageType.Error, message)

    '''

        try:

            forTraining = worker.isTrainingChecked

            symbolName = targetSymbol.getName()

            symbolType = targetSymbol.getType()

            symbolPath = targetSymbol.getPath()

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

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

            offsetDrawingArea = []

            if area is not None:

                offsetDrawingArea.append(area.x)

                offsetDrawingArea.append(area.y)

            else:

                offsetDrawingArea.append(0)

                offsetDrawingArea.append(0)

                if isDetectOnOrigin == 1:

                else:

            roiItemSp = (0, 0)

            roiItemEp = (srcWidth, srcHeight)

            for index in range(2):

                if index is 0:

                # print(symbolOriginalPoint)

                # print(symbolConnectionPoint)

                symbolRotatedAngle = 0

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

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

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

                    if roiw < sw or roih < sh:

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

                        symbolRotatedAngle = symbolRotatedAngle + 90

                            additionalSymbol = Worker.getRotatedChildInfo(additionalSymbol)

                        continue

                    originalPoint = Worker.getCalculatedOriginalPoint(additionalSymbol, symbolOriginalPoint,

                                                                      symbolRotatedAngle, sw, sh, sow, soh)

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

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

                        if overlapArea <= ACCEPT_OVERLAY_AREA:

                            threadLock.acquire()

                            foundSymbolCount = foundSymbolCount + 1

                                                     isDetectOnOrigin, symbolRotateCount, symbolOcrOption,

                                                     isContainChild,

                                                     originalPoint, connectionPoint, baseSymbol, additionalSymbol,

                            threadLock.release()

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

                                searchedSymbol = searchedSymbolList[symbolIndex]

                                if symbolName == searchedSymbol.getName():

                                    symbolHitRate = searchedSymbol.getHitRate()

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

                                                                                        detectFlip=1 if index is 1 else 0,

                                                                                        hasInstrumentLabel=hasInstrumentLabel)

                                        threadLock.release()

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

                                        threadLock.acquire()

                                        foundSymbolCount = foundSymbolCount + 1

                                                                 isContainChild,

                                                                 originalPoint, connectionPoint, baseSymbol,

                                                                 additionalSymbol, isExceptDetect,

                                        threadLock.release()

                                elif not forTraining:

                                    searchedSymbol = searchedSymbolList[symbolIndex]

                                    symbolHitRate = searchedSymbol.getHitRate()

                                                                                                 connectionPoint),

                                                                                        baseSymbol, additionalSymbol,

                                                                                        isExceptDetect,

                                        threadLock.release()

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

                                elif forTraining:

                                                             isContainChild,

                                                             originalPoint, connectionPoint, baseSymbol,

                                                             additionalSymbol, isExceptDetect,

                                    threadLock.release()

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

                    symbolRotatedAngle = symbolRotatedAngle + 90

                foundSymbolCount) + ')')

            threadLock.release()

            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,

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

        return []

            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,

            worker.displayLog(MessageType.Error, message)

        return []

    def addSearchedSymbol(sName, sType

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

                          , isDetectOnOrigin, rotateCount, ocrOption, isContainChild

        global searchedSymbolList

        newSym = None

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

                                   '/'.join('{},{},{},{}'.format(param[0], param[1], param[2], param[3]) for param in

                                            connectionPoint),

            searchedSymbolList.append(newSym)

        except Exception as ex:

            from App import App

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

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

        return newSym

            from App import App

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

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

        return matchCount

            from App import App

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

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

    '''

            from App import App

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

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

        '''

        self.ui.progressBarBatch.setMaximum(maxValue * 5)

        value = self.ui.progressBarBatch.value() + weight

        self.ui.progressBarBatch.setFormat('{}/{}'.format(str(int(value / 5)), str(maxValue)))

    '''

            from App import App

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

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

        finally:

            self.tmStop = timeit.default_timer()

import TextDataList_UI

from EngineeringTextItem import QEngineeringTextItem

class forDoubleClicked():

    def buttons(self):

        return Qt.LeftButton

class QTextDataListDialog(QDialog):

    """

    This is text image data list dialog class

        self.setWindowFlag(Qt.WindowMinMaxButtonsHint)

        # for List 

        self.ui.tableWidget.setColumnCount(2)

        self.ui.tableWidget.setSortingEnabled(True)

        allowed_error = 0.001

        for textItem in self.textItems:

            imageWidget = QTableWidgetItem()

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

                pass

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

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            print(message)

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

        if not force and textItem.scene() is not None:

            try:

                if reply == QMessageBox.Yes:

                    textItem.transfer.onRemoved.emit(textItem)

                    self.ui.tableWidget.removeRow(row)

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

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

        else:

            # item already was deleted from scene

            QMessageBox.warning(self, 'Notice', 'The item does not exist in the scene.')

            self.ui.tableWidget.removeRow(row)

    def listCellClicked(self, row, col):

        from HighlightCommand import HighlightCommand

                        row -= 1

                        HighlightCommand(self.graphicsView).execute(self.ui.tableWidget.item(row, 1).tag)

                        self.ui.tableWidget.setCurrentItem(self.ui.tableWidget.item(row, col))

                elif event.key() == Qt.Key_Down:

                    if row is not self.ui.tableWidget.rowCount() - 1:

                        HighlightCommand(self.graphicsView).execute(self.ui.tableWidget.item(row, 1).tag)

                        self.ui.tableWidget.setCurrentItem(self.ui.tableWidget.item(row, col))

            except Exception as ex:

                pass

        except Exception as ex:

            from App import App

            from AppDocData import MessageType