HYTOS

        self._imgSrc = None

        self._imgSrc = None

        @brief      getter of imgSrc

        @author     humkyung

        @date       2018.07.30

    '''

    @property

    def imgSrc(self):

        import cv2

        if self._imgSrc is None and self._imgFilePath is not None and os.path.isfile(self._imgFilePath):

            self._imgSrc = cv2.cvtColor(cv2.imread(self._imgFilePath), cv2.COLOR_BGR2GRAY)

            kernel = np.array([[-1,-1,-1], 

                   [-1, 9,-1],

                   [-1,-1,-1]])

            self._imgSrc = cv2.filter2D(self._imgSrc, -1, kernel)

            #blur = cv2.GaussianBlur(self._imgSrc , (5,5), 0)

            #smooth = cv2.addWeighted(blur, 1.5, self._imgSrc, -0.5, 0)

            #self._imgSrc = cv2.threshold(smooth, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]

            self._imgSrc = cv2.threshold(self._imgSrc, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]

        return self._imgSrc

    '''

        @brief      setter of imgSrc

        @author     humkyung

        @date       2018.07.30

    '''

    @imgSrc.setter

    def imgSrc(self, value):

        self._imgSrc = value

    '''

        @brief      reset imgSrc

        @author     humkyung

        @date       2018.07.30

    '''

    def resetImgSrc(self):

        self._imgSrc = None

    '''

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QCursor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

import sys, os

from AppDocData import AppDocData

import cv2

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

import SymbolEditorDialog

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))) + '\\Shapes')

from SymbolSvgItem import SymbolSvgItem

class CreateSymbolCommand(AbstractCommand.AbstractCommand):

    '''

        @history    2018.05.04  Jeongwoo    Add Parameter

    '''

    def __init__(self, imageViewer, resultTreeWidget, symbolTreeWidget):

        super(CreateSymbolCommand, self).__init__(imageViewer)

        self.name = 'CreateSymbol'

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

        self.resultTreeWidget = resultTreeWidget

        self.symbolTreeWidget = symbolTreeWidget

    '''

        @brief  crop image by rectangle selected by user

        @history    2018.05.02  Jeongwoo    Init self.offsetX and self.offsetY

                                            Add QtImageViewer.startPointChanged.emit

                    2018.05.03  Jeongwoo    Make Svg/Image File Path by SymbolBase.getSvgFileFullePath() and SymbolBase.getImageFileFullPath()

                    2018.05.04  Jeongwoo    Add self.symbolTreeWidget.initTreeWidget()

                    2018.06.08  Jeongwoo    Add Parameter on SymbolSvgItem.buildItem()

    '''

    def execute(self, param):

        event = param[1]

        scenePos = param[2]

        if 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            self.imageViewer.setDragMode(QGraphicsView.RubberBandDrag)

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

            QGraphicsView.mousePressEvent(self.imageViewer, event)

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

            try:

                QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                viewBBox = self.imageViewer.zoomStack[-1] if len(self.imageViewer.zoomStack) else self.imageViewer.sceneRect()

                selectionBBox = self.imageViewer.scene.selectionArea().boundingRect().intersected(viewBBox)

                if selectionBBox.isValid():

                    croppedImage = self.imageViewer.image().copy(selectionBBox.toAlignedRect())

                    symbolEditorDialog = SymbolEditorDialog.QSymbolEditorDialog(self.imageViewer, croppedImage, AppDocData.instance().getCurrentProject())

                    (isAccepted, isImmediateInsert, offsetX, offsetY, newSym) = symbolEditorDialog.showDialog()

                    self.symbolTreeWidget.initSymbolTreeWidget()

                    if isAccepted:

                        if isImmediateInsert:

                            svgPath = newSym.getSvgFileFullPath()

                            img = cv2.imread(newSym.getImageFileFullPath(), 1)

                            w, h = (0, 0)

                            if len(img.shape[::-1]) == 2:

                                w, h = img.shape[::-1]

                            else:

                                _chan, w, h = img.shape[::-1]

                            svg = SymbolSvgItem(svgPath)

                            svg.buildItem(newSym.getName(), newSym.getType(), 0, [selectionBBox.x()+offsetX, selectionBBox.y()+offsetY], [w, h], [float(x) for x in newSym.getOriginalPoint().split(',')], [(float(x.split(',')[0]), float(x.split(',')[1])) for x in newSym.getConnectionPoint().split('/')], newSym.getBaseSymbol(), newSym.getAdditionalSymbol())

                            #### lambda param=svg : bind 'svg' object to lambda('param')

                            #### If case of 'lambda svg=svg:', function uses the 'svg' value bound to lambda

                            svg.clicked.connect(lambda param=svg: self.resultTreeWidget.findItem(param))

                            svg.transfer.onRemoved.connect(self.resultTreeWidget.itemRemoved)

                            svg.addSvgItemToScene(self.imageViewer.scene)

                            for connector in svg.connectors:

                                self.imageViewer.scene.addItem(connector)

            finally:

                self.imageViewer.setDragMode(QGraphicsView.NoDrag)

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

                pass

        self.isTreated = False

    def undo(self):

        pass

    def redo(self):

        pass

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

# coding: utf-8

import os.path

import sys

try:

    from PyQt5.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QColor

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QRect

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QCursor, QColor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

import numpy as np

import AbstractCommand

class FitImageCommand(AbstractCommand.AbstractCommand):

    WHITE_PIXEL = (255, 255, 255, 255)

    BLACK_PIXEL = (0, 0, 0, 255)

    '''

        @history    2018.05.02  Jeongwoo    Change variable name (adjustX, adjustY → offsetX, offsetY)

    '''

    def __init__(self, imageViewer):

        super(FitImageCommand, self).__init__(imageViewer)

        self.name = 'FitImage' 

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

        boundingBox = self.getImageBoundingBox()

        croppedImage = self.imageViewer.image().copy(boundingBox)

        self.imageViewer.setImage(croppedImage)

        self.offsetX = boundingBox.left()

        self.offsetY = boundingBox.top()

    '''

        @history    2018.05.02  Jeongwoo    Change method name (getAdjust → getOffset)

    '''

    def getOffset(self):

        return (self.offsetX, self.offsetY)

    def convertQImageToMat(self, incomingImage):

        '''  Converts a QImage into an opencv MAT format  '''

        try:

            incomingImage = incomingImage.convertToFormat(QImage.Format_RGBA8888)

            width = incomingImage.width()

            height = incomingImage.height()

            ptr = incomingImage.bits()

            ptr.setsize(incomingImage.byteCount())

            arr = np.array(ptr).reshape(height, width, 4)  #  Copies the data

            return arr

        except Exception as ex:

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

    '''

        @brief      get minimum image bouding box

        @author     jeongwoo

        @date       

    '''

    def getImageBoundingBox(self):

        import cv2

        black = 0

        image = self.convertQImageToMat(self.imageViewer.image())

        image = cv2.threshold(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]

        indices = np.where(image == [0])

        minx, maxx = min(indices[1]), max(indices[1])

        miny, maxy = min(indices[0]), max(indices[0])

        return QRect(minx, miny, (maxx - minx) + 1, (maxy - miny) + 1)

    '''

        @brief  DO NOTHING

    '''

    def execute(self, param):

        pass

    def undo(self):

        pass

    def redo(self):

        pass

# coding: utf-8

"""

This is place line module

"""

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import Qt, QPointF, QRectF, pyqtSignal, QT_VERSION_STR

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QCursor, QTransform

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QCursor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class PlaceLineCommand(AbstractCommand.AbstractCommand):

    """

    This is place line class

    """

    onSuccess = pyqtSignal()

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    def __init__(self, imageViewer):

        super(PlaceLineCommand, self).__init__(imageViewer)

        self.name = 'PlaceLine' 

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

        self._polyline = None

    '''

        @brief      reset command status

        @author     humkyung

        @date       2018.07.23

    '''

    def reset(self):

        self._polyline = None

    '''

        @brief      place a line

        @author     humkyung

        @date       2018.07.23

    '''

    def execute(self, param):

        import shapely

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringPolylineItem import QEngineeringPolylineItem

        from EngineeringLineItem import QEngineeringLineItem

        self.isTreated = False

        event = param[1]

        if 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            if self._polyline is None:

                selected = self.imageViewer.scene.itemAt(param[2], QTransform())

                if selected is not None and type(selected) is QEngineeringConnectorItem:

                    self._polyline = QEngineeringPolylineItem()

                    self._polyline._vertices.append(selected.center())

                    self.imageViewer.scene.addItem(self._polyline)

                    self.imageViewer.scene.setFocusItem(self._polyline)

                elif selected is not None and type(selected) is QEngineeringLineItem:

                    length = selected.length()*0.5

                    dir = selected.perpendicular()

                    start = [param[2].x() - dir[0]*length, param[2].y() - dir[1]*length]

                    end = [param[2].x() + dir[0]*length, param[2].y() + dir[1]*length]

                    pt = selected.intersection([start, end])

                    if (pt is not None) and (type(pt) == shapely.geometry.point.Point):

                        self._polyline = QEngineeringPolylineItem()

                        self._polyline._vertices.append([pt.x, pt.y])

                        self.imageViewer.scene.addItem(self._polyline)

                        self.imageViewer.scene.setFocusItem(self._polyline)

            else:

                try:

                    QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    self._polyline._vertices.append(self._polyline._pt)

                    self._polyline.update()

                finally:

                    pass

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton and self._polyline is not None:

            self.onSuccess.emit()

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton and self._polyline is None:

            self.onRejected.emit(self)

        elif 'mouseMoveEvent' == param[0] and self._polyline is not None:

            self._polyline.onMouseMoved(event, param[2])

        elif 'keyPressEvent' == param[0]:

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

                self.onRejected.emit(self)

                self.isTreated = False

            elif event.key() == Qt.Key_A:   # axis lock mode

                self._polyline.drawing_mode = QEngineeringPolylineItem.AXIS_MODE

            elif event.key() == Qt.Key_F:   # free drawing mode 

                self._polyline.drawing_mode = QEngineeringPolylineItem.FREE_MODE

    def undo(self):

        pass

    def redo(self):

        pass

# coding: utf-8

import os.path

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog, QCursor

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

class PlacePolygonCommand(AbstractCommand.AbstractCommand):

    """

    This is place polygon class

    """

    onSuccess = pyqtSignal()

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    def __init__(self, imageViewer):

        super(PlacePolygonCommand, self).__init__(imageViewer)

        self.name = 'PlaceLine' 

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

        self._polyline = None

    '''

        @brief      reset command status

        @author     humkyung

        @date       2018.07.23

    '''

    def reset(self):

        self._polyline = None

    '''

        @brief      place a line

        @author     humkyung

        @date       2018.07.23

    '''

    def execute(self, param):

        import shapely

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from EngineeringPolylineItem import QEngineeringPolylineItem

        from EngineeringLineItem import QEngineeringLineItem

        self.isTreated = False

        event = param[1]

        if 'mousePressEvent' == param[0] and event.button() == Qt.LeftButton:

            try:

                if self._polyline is None:

                    self._polyline = QEngineeringPolylineItem()

                    self._polyline.drawing_mode = QEngineeringPolylineItem.FREE_MODE

                    self._polyline._vertices.append((param[2].x(), param[2].y()))

                    self.imageViewer.scene.addItem(self._polyline)

                    self.imageViewer.scene.setFocusItem(self._polyline)

                else:

                    QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    self._polyline._vertices.append(self._polyline._pt)

                    self._polyline.update()

            finally:

                pass

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton and self._polyline is not None:

            self.onSuccess.emit()

        elif 'mouseReleaseEvent' == param[0] and event.button() == Qt.RightButton and self._polyline is None:

            self.onRejected.emit(self)

        elif 'mouseMoveEvent' == param[0] and self._polyline is not None:

            self._polyline.onMouseMoved(event, param[2])

        elif 'keyPressEvent' == param[0]:

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

                self.onRejected.emit(self)

                self.isTreated = False

    def undo(self):

        pass

    def redo(self):

        pass

# coding: utf-8

""" This is select attribute command module """

import os.path

import sys

import AbstractCommand

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR, QEvent

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImge, QPixmap, QPainterPath, QFileDialog, QCursor, QMouseEvent

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

'''

    @brief      QtImageViewer Select Attribute Command

    @author     kyouho

    @date       18.04.10

'''

class SelectAttributeCommand(AbstractCommand.AbstractCommand):

    onSuccess = pyqtSignal()

    def __init__(self, item, attr, imageViewer):

        super(SelectAttributeCommand, self).__init__(imageViewer)

        self.name = 'SelectAttribute'

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

        self._item = item

        self._attr = attr

    '''

        @brief      Select Attribuew

        @author     kyouho

        @date       18.07.19

        @history    euising  2019.01.15  add specbreak

        @history    add Valve Oper Item 2019.04.15 by humkyung

    '''

    def execute(self, param):

        from SymbolAttr import SymbolAttr

        from SymbolAttr import SymbolProp

        event = param[1]

        scenePos = param[2]

        try:

            if 'mouseReleaseEvent' == param[0] and event.button() == Qt.LeftButton:

                from EngineeringAbstractItem import QEngineeringAbstractItem

                from SymbolSvgItem import SymbolSvgItem

                from EngineeringTextItem import QEngineeringTextItem

                from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

                from EngineeringRunItem import QEngineeringRunItem

                from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

                from EngineeringLineItem import QEngineeringLineItem

                from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

                from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

                from EngineeringConnectorItem import QEngineeringConnectorItem

                from EngineeringEndBreakItem import QEngineeringEndBreakItem

                from EngineeringVendorItem import QEngineeringVendorItem

                from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

                if self._attr is not None and type(self._attr) is SymbolAttr:

                    item = self.imageViewer.scene.itemAt(scenePos, QTransform())

                    if item is not None and self._attr.AttributeType == 'Line Item' and issubclass(type(item), QEngineeringLineItem):

                        self._item.conns.clear()

                        self._item.conns.append(item)

                        self.onSuccess.emit()

                    elif item is not None and self._attr.AttributeType == 'CONN' and (issubclass(type(item), QEngineeringLineItem) or issubclass(type(item), SymbolSvgItem) or type(item) is QEngineeringVendorItem or type(item) is QEngineeringReservedWordTextItem):

                        self._item.connectors[self._attr.AttrAt - 1].connect(item, QEngineeringAbstractItem.CONNECTED_AT_BODY)

                        if type(item) is QEngineeringReservedWordTextItem:

                            item.owner = self._item

                        self.onSuccess.emit()

                    elif item is not None and self._attr.AttributeType == 'CONN' and (type(item) is QEngineeringConnectorItem):

                        self._item.connectors[self._attr.AttrAt - 1].connect(item.parent, QEngineeringAbstractItem.CONNECTED_AT_PT)

                        self.onSuccess.emit()

                    elif item is not None and issubclass(type(self._item), QEngineeringSpecBreakItem) and self._attr.AttributeType == 'Comp Item' and type(item) is not QGraphicsPixmapItem:

                        self._item.attrs[self._attr] = str(item.uid)

                        self.onSuccess.emit()

                    elif item is not None and (type(self._item) is not QEngineeringEndBreakItem) and (type(item) is QEngineeringLineNoTextItem) and self._attr.AttributeType == 'OWNER':

                        if not item.runs:

                            item.runs.append(QEngineeringRunItem())

                        if 1 == len(item.runs): item.runs[0].items.append(self._item)

                        self._item.owner = item

                        self.onSuccess.emit()

                    elif item is not None and (type(self._item) is QEngineeringEndBreakItem or issubclass(type(self._item), QEngineeringTextItem)) and (type(item) is QEngineeringLineItem or issubclass(type(item), SymbolSvgItem)) and self._attr.AttributeType == 'OWNER':

                        self._item.owner = item

                        self.onSuccess.emit()

                    #elif item is not None and (type(self._item) is QEngineeringEndBreakItem) and (type(item) is QEngineeringLineItem) and self._attr.Attribute == 'Connected Line':

                    #    self._item.attrs[self._attr] = str(item.uid)

                    #    self.onSuccess.emit()

                    elif item is not None and self._attr.AttributeType == QEngineeringAbstractItem.assoc_type(item):

                        if self._attr.Freeze:

                            self.onSuccess.emit()

                            return

                        if self._attr.AttributeType not in self._item._associations:

                            self._item._associations[self._attr.AttributeType] = []

                        while len(self._item._associations[self._attr.AttributeType]) <= self._attr.AttrAt:

                            self._item._associations[self._attr.AttributeType].append(None)

                        self._item.add_assoc_item(item, self._attr.AttrAt)

                        for key in self._item.attrs.keys():

                            if key.Attribute == self._attr.Attribute:

                                key.AssocItem = item

                                break

                        if issubclass(type(item), QEngineeringTextItem): item.owner = self._item

                        self.onSuccess.emit()

                elif self._attr is not None and type(self._attr) is SymbolProp:

                    item = self.imageViewer.scene.itemAt(scenePos, QTransform())

                    if item is not None and self._attr.match_type(item):

                        self._item.set_property(self._attr.Attribute, item)

                        if issubclass(type(item), QEngineeringTextItem): item.owner = self._item

                        self.onSuccess.emit()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occured({}) 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.isTreated = True

    def undo(self):

        pass

    def redo(self):

        pass

    '''

        @brief      Find TextItem contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findTextItemInPoint(self, point):

        from EngineeringTextItem import QEngineeringTextItem

        for item in self.imageViewer.items():

            if type(item) is QEngineeringTextItem:

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Find Symbol Item contain Point

        @author     kyouho

        @date       18.07.19

    '''

    def findSymbolItemInPoint(self, point):

        from SymbolSvgItem import SymbolSvgItem

        for item in self.imageViewer.items():

            if issubclass(type(item), SymbolSvgItem):

                if self.isOverlapItemAndPoint(item, point):

                    return (True, item)

        return (False,)

    '''

        @brief      Check Overlap

        @author     kyouho

        @date       18.07.17

    '''

    def isOverlapItemAndPoint(self, item, point):

        x = point.x()

        y = point.y()

        loc = item.loc

        size = item.size

        if loc[0] <= x and loc[0] + size[0] >= x and loc[1] <= y and loc[1] + size[1] >= y:

            return True

        else:

            return False

# coding: utf-8

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

import ConnectAttr_UI

import sys

import os

import cv2

from AppDocData import *

from LineDetector import LineDetector

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

'''

'''

class Worker(QThread):

    """ This is Worker class """

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

    from QtImageViewer import QtImageViewer

    import sys

    '''

    '''

    finished = pyqtSignal()

    intReady = pyqtSignal(int)

    displayMessage = pyqtSignal(str)

    updateProgress = pyqtSignal(int)

    def __init__(self, graphicsView, update_line_type):

        QThread.__init__(self)

        self.graphicsView = graphicsView

        self._update_line_type = update_line_type

    '''

        @brief  execute connecting attributes

        @author humkyung

        @date   2018.06.17

    '''

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

        from LineNoTracer import connectAttrImpl

        try:

            connectAttrImpl(self, self._update_line_type)

        except Exception as ex:

            from App import App 

            message = 'error occured({}) 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)

class QConnectAttrDialog(QDialog):

    """ This is connect attr dialog class """

    def __init__(self, parent, graphicsView): #Parent is MainWindow

        import ConnectAttr_UI

        QDialog.__init__(self, parent)

        self.parent = parent

        self.graphicsView = graphicsView

        self.ui = ConnectAttr_UI.Ui_ConnectAttr()

        self.ui.setupUi(self)

        self.ui.pushButtonStart.setFocus()

        self.ui.buttonBox.setEnabled(True)

        self.ui.listWidget.model().rowsInserted.connect(self.rowInserted) ## connect to func rowInserted(self, item)

        self.isAccepted = False

        self.ui.pushButtonStart.clicked.connect(self.connStart)

    def connStart(self):

        '''

            @brief  connection start

            @author euisung

            @date   2019.02.25

        ''' 

        self.ui.buttonBox.setEnabled(False)

        self.ui.pushButtonStart.setEnabled(False)

        self.ui.progressBar.setValue(0)

        self.startThread()

        """ for DEBUG

        from LineNoTracer import connectAttrImpl

        connectAttrImpl(self)

        """

    '''

        @brief      QListWidget Row Inserted Listener

                    Whenever row inserted, scroll to bottom

        @author     Jeongwoo

        @date       18.04.12

    '''

    def rowInserted(self, item):

        self.ui.listWidget.scrollToBottom()

    '''

        @brief  add item to list widget

        @author humkyung

        @date   2018.06.17

    '''

    def addListItem(self, msg):

        self.ui.listWidget.addItem(msg)

    def accept(self):

        self.isAccepted = True

        QDialog.accept(self)

    '''

        @brief      update progressbar with given value

        @author     humkyung

        @date       2018.06.17

        @history    humkyung 2018.06.27 reset value if maxValue is -1

    '''

    def updateProgress(self, maxValue):

        if maxValue != -1:

            self.ui.progressBar.setMaximum(maxValue)

            self.ui.progressBar.setValue(self.ui.progressBar.value() + 1)

        else:

            self.ui.progressBar.setValue(0)

    '''

        @brief  start thread

        @author humkyung

        @date   2018.06.17

    '''

    def startThread(self):

        import timeit

        from LineNoTracer import connectAttrImpl

        try:

            self.ui.buttonBox.setDisabled(True)

            # 1 - create Worker and Thread inside the Form

            self.obj = Worker(self.graphicsView, self.ui.checkBoxUpdateLineType.isChecked())

            # 2 - Connect Worker Signals to the Thread slots

            self.obj.displayMessage.connect(self.addListItem)

            self.obj.updateProgress.connect(self.updateProgress)

            # 3 - Thread finished signal will close the app if you want!

            self.obj.finished.connect(self.dlgExit)

            # 4 - Start the thread

            self.obj.start()

            self.tmStart = timeit.default_timer()

        except Exception as ex:

            from App import App 

            message = 'error occured({}) 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)

        finally:

            self.ui.buttonBox.setDisabled(False)

    '''

        @brief      set buttonbox's enabled flag

        @author     humkyung

        @date       2018.06.17

        @history    humkyung 2018.06.17 add flow mark for pipe run

                    humkyung 2018.08.16 don't update line type according to connected items

    '''

    def dlgExit(self):

        import timeit

        try:

            self.ui.progressBar.setValue(self.ui.progressBar.maximum())

            self.ui.buttonBox.setEnabled(True)

        except Exception as ex:

            from App import App

            message = 'error occured({}) 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)

        finally:

            self.tmStop = timeit.default_timer()    

            seconds = self.tmStop - self.tmStart

            self.ui.listWidget.addItem("\nRunning Time : {} min".format(str(round(seconds/60, 1))) + "\n")

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file '.\UI\dlgConnectAttr.ui'

#

# Created by: PyQt5 UI code generator 5.11.3

#

# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_ConnectAttr(object):

    def setupUi(self, ConnectAttr):

        ConnectAttr.setObjectName("ConnectAttr")

        ConnectAttr.setWindowModality(QtCore.Qt.WindowModal)

        ConnectAttr.resize(845, 453)

        font = QtGui.QFont()

        font.setFamily("맑은 고딕")

        ConnectAttr.setFont(font)

        self.gridLayout = QtWidgets.QGridLayout(ConnectAttr)

        self.gridLayout.setObjectName("gridLayout")

        self.listWidget = QtWidgets.QListWidget(ConnectAttr)

        self.listWidget.setObjectName("listWidget")

        self.gridLayout.addWidget(self.listWidget, 3, 0, 1, 1)

        self.horizontalLayout = QtWidgets.QHBoxLayout()

        self.horizontalLayout.setObjectName("horizontalLayout")

        self.progressBar = QtWidgets.QProgressBar(ConnectAttr)

        self.progressBar.setProperty("value", 0)

        self.progressBar.setObjectName("progressBar")

        self.horizontalLayout.addWidget(self.progressBar)

        self.buttonBox = QtWidgets.QDialogButtonBox(ConnectAttr)

        self.buttonBox.setEnabled(False)

        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)

        sizePolicy.setHorizontalStretch(0)

        sizePolicy.setVerticalStretch(0)

        sizePolicy.setHeightForWidth(self.buttonBox.sizePolicy().hasHeightForWidth())

        self.buttonBox.setSizePolicy(sizePolicy)

        self.buttonBox.setOrientation(QtCore.Qt.Horizontal)

        self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Close)

        self.buttonBox.setObjectName("buttonBox")

        self.horizontalLayout.addWidget(self.buttonBox, 0, QtCore.Qt.AlignRight)

        self.gridLayout.addLayout(self.horizontalLayout, 6, 0, 1, 1)

        self.horizontalLayout_2 = QtWidgets.QHBoxLayout()

        self.horizontalLayout_2.setObjectName("horizontalLayout_2")

        self.checkBoxUpdateLineType = QtWidgets.QCheckBox(ConnectAttr)

        self.checkBoxUpdateLineType.setObjectName("checkBoxUpdateLineType")

        self.horizontalLayout_2.addWidget(self.checkBoxUpdateLineType)

        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)

        self.horizontalLayout_2.addItem(spacerItem)

        self.pushButtonStart = QtWidgets.QPushButton(ConnectAttr)

        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)

        sizePolicy.setHorizontalStretch(0)

        sizePolicy.setVerticalStretch(0)

        sizePolicy.setHeightForWidth(self.pushButtonStart.sizePolicy().hasHeightForWidth())

        self.pushButtonStart.setSizePolicy(sizePolicy)

        self.pushButtonStart.setObjectName("pushButtonStart")

        self.horizontalLayout_2.addWidget(self.pushButtonStart)

        self.gridLayout.addLayout(self.horizontalLayout_2, 2, 0, 1, 1)

        self.retranslateUi(ConnectAttr)

        self.buttonBox.clicked['QAbstractButton*'].connect(ConnectAttr.accept)

        QtCore.QMetaObject.connectSlotsByName(ConnectAttr)

        ConnectAttr.setTabOrder(self.pushButtonStart, self.listWidget)

    def retranslateUi(self, ConnectAttr):

        _translate = QtCore.QCoreApplication.translate

        ConnectAttr.setWindowTitle(_translate("ConnectAttr", "Connect Attribute"))

        self.checkBoxUpdateLineType.setText(_translate("ConnectAttr", "Update Line Type"))

        self.pushButtonStart.setText(_translate("ConnectAttr", "Start"))

# coding: utf-8

"""

    This is fluid code dialog module

"""

import sys

import sqlite3

import os

import cv2

import math

import threading

import multiprocessing

from multiprocessing import Process, Queue

from shapely.geometry import Point

from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import AppDocData

import DetectSymbol_UI

class QDetectSymbolDialog(QDialog):

    def __init__(self, parent):

        QDialog.__init__(self)

        self.parent = parent

        self.ui = DetectSymbol_UI.Ui_DetectSymbolDialog()

        self.ui.setupUi(self)

        self.table = self.ui.tableWidgetSymbol

        self.currentRow = 0

        self.currentColumn = 0

        ## box dir setting

        self.boxDir = AppDocData.instance().getCurrentProject().path + '/box/'

        if not os.path.exists(self.boxDir):

            os.makedirs(self.boxDir)

        ## drawing file setting

        self.drawingDir = AppDocData.instance().getCurrentProject().path + '/drawings/'

        if os.path.exists(self.drawingDir):

            files = os.listdir(self.drawingDir)

            for file in files:

                listItem = QListWidgetItem()

                listItem.setData(32, file)

                listItem.setText(os.path.splitext(file)[0])

                self.ui.listWidgetDrawings.addItem(listItem)

        self.ui.listWidgetDrawings.currentTextChanged.connect(self.currentTextChangedEvent)

        self.ui.pushButtonDetectSymbol.clicked.connect(self.detectSymbol)

        if self.ui.listWidgetDrawings.count():

            self.ui.listWidgetDrawings.setCurrentRow(0)

        self.table.cellDoubleClicked.connect(self.cellDoubleClickedEvent)

        self.table.currentCellChanged.connect(self.currentCellChangedEvent)

        self.setAllSymbolsTable()

    '''

        @brief  current cell chage event

        @author kyouho

        @date   2018.10.01

    '''

    def currentCellChangedEvent(self, currentRow, currentColumn, previousRow, previousColumn):

        currentItem = self.table.cellWidget(currentRow, currentColumn)

        if currentItem is not None:

            self.currentRow = currentRow

            self.currentColumn = currentColumn

        else:

            self.currentRow = -1

            self.currentColumn = -1

    '''

        @brief  cell double click event

        @author kyouho

        @date   2018.10.01

    '''

    def cellDoubleClickedEvent(self, row, column):

        cell = self.table.cellWidget(row,column)

        if cell is not None:

            import SymbolEditorDialog

            symbolEditorDialog = SymbolEditorDialog.QSymbolEditorDialog(self, cell.pixmap(), AppDocData.instance().getCurrentProject())

            (isAccepted, isImmediateInsert, offsetX, offsetY, newSym) = symbolEditorDialog.showDialog()

            if isAccepted:

                self.table.removeCellWidget(row, column)

                self.parent.symbolTreeWidget.initSymbolTreeWidget()

                self.setAllSymbolsTable()

    '''

        @brief  text changed Event

        @author kyouho

        @date   2018.09.18

    '''

    def currentTextChangedEvent(self, text):

        self.imageName = text

        self.imgPath = self.drawingDir + self.ui.listWidgetDrawings.currentItem().data(32)

        self.tableSetting()

    '''

        @brief  text changed Event

        @author kyouho

        @date   2018.10.11

    '''

    def setAllSymbolsTable(self):

        table = self.ui.tableWidgetAllSymbols

        table.setRowCount(0)

        imageFiles = []

        imageDir = AppDocData.instance().getCurrentProject().path + '/image/'

        self.findFiles(imageDir, imageFiles)

        table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)

        size = table.maximumWidth() - 40

        table.setRowCount(len(imageFiles))

        row = 0

        for path in imageFiles:

            cell = QLabel()

            pixmap = QPixmap(path)

            cell.setPixmap(pixmap.scaled(size, size, Qt.KeepAspectRatio))

            table.setCellWidget(row, 0, cell)

            row = row + 1

        table.resizeRowsToContents()

    '''

        @brief  find image files

        @author kyouho

        @date   2018.10.11

    '''

    def findFiles(self, dir, list):

        fileList = os.listdir(dir)

        for file in fileList:

            path = os.path.join(dir, file)

            if os.path.isdir(path):

                self.findFiles(path, list)

            elif os.path.splitext(path)[1] == '.png':

                list.append(path)

    '''

        @brief  text changed Event

        @author kyouho

        @date   2018.09.18

    '''

    def detectSymbol(self):

        if not self.ui.listWidgetDrawings.count():

            return

        self.progress = QProgressDialog("잠시만 기다려주세요", "Cancel", 0, 100, self)

        self.progress.setWindowModality(Qt.WindowModal)

        self.progress.setAutoReset(True)

        self.progress.setAutoClose(True)

        self.progress.setMinimum(0)

        self.progress.resize(600,100)

        self.progress.setWindowTitle("인식 중...")

        self.progress.show()

        self.progress.setMaximum(100)

        self.progress.setValue(0)

        QApplication.processEvents()

        from TextDetector import TextDetector

        import numpy as np

        appDocData = AppDocData.instance()

        ## textDetector에서 사용하기 때문에 설정

        appDocData.imgName = self.imageName

        ## 흑색 이미지로 변환

        img = cv2.imread(self.imgPath, 1)

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

        ## 프로젝트의 Drawing Area data

        area = appDocData.getArea('Drawing')

        ## area 영역 자른 offset

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

        ## 이미지 이진화

        thresholdImg = cv2.threshold(imgGray , 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]

        ## 프로젝트의 Area 영역만큼만 자른 이미지

        areaImg = thresholdImg[round(area.y):round(area.y+area.height), round(area.x):round(area.x+area.width)]

        ## 선제거 전에 먼저 작은 영역 제거

        ## contours 추출을 위한 색반전

        areaImg = cv2.bitwise_not(areaImg) 

        ## contours 추출

        image, contours, hierarchy = cv2.findContours(areaImg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        for contour in contours:

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

            if (w < 40 or h < 40): 

                areaImg[y:y+h,x:x+w] = 0

        ## 다시 색반전

        areaImg = cv2.bitwise_not(areaImg) 

        ## find lines

        verticalLineList = []

        horizontalLineList = []

        self.findLines(areaImg, verticalLineList, horizontalLineList)

        ## chage color

        for vLine in verticalLineList:

            p1 = vLine[0]

            p2 = vLine[1]

            x = p1[0]

            areaImg[p1[1]:p2[1], x] = 255

        ## chage color

        for vLine in horizontalLineList:

            p1 = vLine[0]

            p2 = vLine[1]

            y = p1[1]

            areaImg[y, p1[0]:p2[0]] = 255

        ## contours 추출을 위한 색반전

        areaImg = cv2.bitwise_not(areaImg) 

        ## contours 추출

        recList = self.getContours(areaImg)

        ## to xml

        self.toXml(recList, offset)

        ## table setting

        self.tableSetting()

        self.progress.setValue(self.progress.maximum())

    '''

        @brief  find lines

        @author kyouho

        @date   2018.10.01

    '''

    def findLines(self, areaImg, verticalLineList, horizontalLineList):

        ## for multiprocessing

        verticalProcessList = []

        horizontalProcessList = []

        ## Find VerticalLine using multiprocessing

        ## Set Vertical Line

        jumpValue = int(areaImg.shape[1] / os.cpu_count())

        value = 0

        for cpuIndex in range(os.cpu_count()):

            _queue = Queue()

            _range = value + jumpValue

            if os.cpu_count() -1 == cpuIndex:

                _range = areaImg.shape[1]

            _process = Process(target=isVerticalLineThread, args=(value, _range, areaImg, _queue))

            _process.daemon = True

            verticalProcessList.append((_process, _queue))

            value = value + jumpValue

        ## Set Horizontal Line

        jumpValue = int(areaImg.shape[0] / os.cpu_count())

        value = 0

        for cpuIndex in range(os.cpu_count()):

            _queue = Queue()

            _range = value + jumpValue

            if os.cpu_count() -1 == cpuIndex:

                _range = areaImg.shape[0]

            _process = Process(target=isHorizontalLineThread, args=(value, _range, areaImg, _queue))

            _process.daemon = True

            horizontalProcessList.append((_process, _queue))

            value = value + jumpValue

        ## set percent

        progressCount = len(verticalProcessList) + len(horizontalProcessList) + 1

        percentGage = int(100 / progressCount)

        percent = percentGage

        self.progress.setValue(percent)

        QApplication.processEvents()

        ## process start

        for process in verticalProcessList:

            process[0].start()

        ## Wait Vertical And Start Horizontal 

        for index in range(len(verticalProcessList)):

            verticalLineList.extend(verticalProcessList[index][1].get())

            verticalProcessList[index][0].join()

            verticalProcessList[index][1].close()

            percent = percent + percentGage

            self.progress.setValue(percent)

            QApplication.processEvents()

            horizontalProcessList[index][0].start()

        ## Wait Horizontal 

        for process in horizontalProcessList:

            horizontalLineList.extend(process[1].get())

            process[0].join()

            process[1].close()

            percent = percent + percentGage

            self.progress.setValue(percent)

            QApplication.processEvents()

    '''

        @brief  get contours

        @author kyouho

        @date   2018.10.01

    '''

    def getContours(self, areaImg):

        image, contours, hierarchy = cv2.findContours(areaImg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        ## RecList 정리

        lineWidth = 5

        recList = []

        tempRecList = []

        for contour in contours:

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

            tempRecList.append([x-lineWidth, y-lineWidth, x+w+lineWidth, y+h+lineWidth])

        ## Overlap Rec 합침

        while len(tempRecList):

            rec1 = tempRecList[0]

            _temp = []

            for index in range(1, len(tempRecList)):

                rec2 = tempRecList[index]

                if rec1[0] <= rec2[2] and rec1[2] >= rec2[0] and rec1[1] <= rec2[3] and rec1[3] >= rec2[1]:

                    _temp.append(rec2)

            if len(_temp):

                x1 = rec1[0]

                y1 = rec1[1]

                x2 = rec1[2]

                y2 = rec1[3]

                for rec in _temp:

                    x1 = min(x1, rec[0])

                    y1 = min(y1, rec[1])

                    x2 = max(x2, rec[2])

                    y2 = max(y2, rec[3])

                    tempRecList.remove(rec)

                tempRecList.append([x1, y1, x2, y2])

            else:

                recList.append(rec1)

            tempRecList.remove(rec1)

        return recList

    '''

        @brief  key press event

        @author kyouho

        @date   2018.10.01

    '''

    def keyPressEvent(self, event):

        if event.key() == Qt.Key_Delete and self.currentRow != -1 and self.currentColumn != -1:

            self.table.removeCellWidget(self.currentRow, self.currentColumn)

    '''

        @brief  box to xml

        @author kyouho

        @date   2018.10.01

    '''

    def toXml(self, recList, offset):

        xml = Element('BOXES')

        ## to xml

        for rec in recList:

            [x1, y1, x2, y2] = rec

            w = x2-x1

            h = y2-y1

            if w < 20 or h < 20: continue

            elif w*4<h or h*4<w: continue

            boxElement = Element('BOX')

            xElement = Element('X')

            xElement.text = str(x1 + offset[0])

            boxElement.append(xElement)

            yElement = Element('Y')

            yElement.text = str(y1 + offset[1])

            boxElement.append(yElement)

            widthElement = Element('WIDTH')

            widthElement.text = str(x2-x1)

            boxElement.append(widthElement)

            heightElement = Element('HEIGHT')

            heightElement.text = str(y2-y1)

            boxElement.append(heightElement)

            xml.append(boxElement)

        ElementTree(xml).write(self.boxDir + self.imageName + '.box')

    '''

        @brief  table setting

        @author kyouho

        @date   2018.09.18

    '''

    def tableSetting(self):

        columnCount = 3

        self.table.setColumnCount(columnCount)

        self.table.setRowCount(0)

        boxCount = 0

        xmlPath = self.boxDir + self.imageName + '.box'

        if os.path.exists(xmlPath):

            _pixmap = QPixmap(self.imgPath)

            xml = parse(xmlPath)

            root = xml.getroot()

            for box in root.iter('BOX'):

                rowIndex = int(boxCount / columnCount)

                self.table.setRowCount(rowIndex + 1)

                _x = int(box.find('X').text)

                _y = int(box.find('Y').text)

                _width = int(box.find('WIDTH').text)

                _height = int(box.find('HEIGHT').text)

                rect = QRect(_x, _y, _width, _height)

                boxImg = _pixmap.copy(rect)

                cell = QLabel()

                cell.setPixmap(boxImg)

                cell.rect = [_x, _y, _width, _height]

                self.table.setCellWidget(rowIndex, boxCount % columnCount, cell)

                boxCount = boxCount + 1

            self.table.resizeColumnsToContents()

            self.table.resizeRowsToContents()

    '''

        @brief  accept

        @author kyouho

        @date   2018.10.01

    '''

    def accept(self):

        columnCount = 3

        recList = []

        for rowIndex in range(self.table.rowCount()):

            for columnIndex in range(columnCount):

                cell = self.table.cellWidget(rowIndex, columnIndex)

                if cell is not None:

                    [x, y, w, h] = cell.rect

                    recList.append([x, y, x+w, y+h])

        self.toXml(recList, (0, 0))

        QDialog.accept(self)

'''

    @brief  Check Vertical Line using Multiprocessing

    @author kyouho

    @date   2018.09.27

'''

def isVerticalLineThread(start, end, img, _queue):

    minLineSize = 40

    ## Vertical

    find = False

    startY = 0

    lineList = []

    for x in range(start, end):

        for y in range(0, img.shape[0]):

            if img[y,x] == 0:

                if find:

                    continue

                else:

                    find = True

                    startY = y

            else:

                if find:

                    if y - startY > minLineSize:

                        lineList.append(((x,startY), (x,y)))

                    find = False

    _queue.put(lineList)

'''

    @brief  Check Horizontal Line using Multiprocessing

    @author kyouho

    @date   2018.09.27

'''

def isHorizontalLineThread(start, end, img, _queue):

    minLineSize = 40

    ## Horizontal

    find = False

    startX = 0

    lineList = []

    for y in range(start, end):

        for x in range(0, img.shape[1]):

            if img[y,x] == 0:

                if find:

                    continue

                else:

                    find = True

                    startX = x

            else:

                if find:

                    if x - startX > minLineSize:

                        lineList.append(((startX,y), (x,y)))

                    find = False

    _queue.put(lineList)

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file '.\UI\DetectSymbol.ui'

#

# Created by: PyQt5 UI code generator 5.11.2

#

# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_DetectSymbolDialog(object):

    def setupUi(self, DetectSymbolDialog):

        DetectSymbolDialog.setObjectName("DetectSymbolDialog")

        DetectSymbolDialog.resize(1313, 813)

        font = QtGui.QFont()

        font.setFamily("맑은 고딕")

        DetectSymbolDialog.setFont(font)

        self.gridLayout = QtWidgets.QGridLayout(DetectSymbolDialog)

        self.gridLayout.setObjectName("gridLayout")

        self.gridLayout_2 = QtWidgets.QGridLayout()

        self.gridLayout_2.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint)

        self.gridLayout_2.setObjectName("gridLayout_2")

        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)

        self.gridLayout_2.addItem(spacerItem, 0, 1, 1, 1)

        self.pushButtonDetectSymbol = QtWidgets.QPushButton(DetectSymbolDialog)

        self.pushButtonDetectSymbol.setMinimumSize(QtCore.QSize(0, 25))

        self.pushButtonDetectSymbol.setMaximumSize(QtCore.QSize(16777215, 25))

        self.pushButtonDetectSymbol.setObjectName("pushButtonDetectSymbol")

        self.gridLayout_2.addWidget(self.pushButtonDetectSymbol, 0, 0, 1, 1)

        self.gridLayout.addLayout(self.gridLayout_2, 0, 0, 1, 1)

        self.buttonBox = QtWidgets.QDialogButtonBox(DetectSymbolDialog)

        self.buttonBox.setOrientation(QtCore.Qt.Horizontal)

        self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok)

        self.buttonBox.setObjectName("buttonBox")

        self.gridLayout.addWidget(self.buttonBox, 2, 0, 1, 1)

        self.splitter_2 = QtWidgets.QSplitter(DetectSymbolDialog)

        self.splitter_2.setOrientation(QtCore.Qt.Horizontal)

        self.splitter_2.setObjectName("splitter_2")

        self.splitter = QtWidgets.QSplitter(self.splitter_2)

        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding)

        sizePolicy.setHorizontalStretch(0)

        sizePolicy.setVerticalStretch(0)

        sizePolicy.setHeightForWidth(self.splitter.sizePolicy().hasHeightForWidth())

        self.splitter.setSizePolicy(sizePolicy)

        self.splitter.setMinimumSize(QtCore.QSize(0, 0))

        self.splitter.setMaximumSize(QtCore.QSize(300, 16777215))

        self.splitter.setOrientation(QtCore.Qt.Vertical)

        self.splitter.setObjectName("splitter")