HYTOS

class App(QApplication):

    """ This is App class inherits from QApplication """

    def __init__(self, args):

        import locale

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

class SaveWorkCommand(QThread):

    display_message = pyqtSignal(Enum, str)

    show_progress = pyqtSignal(int)

                        if item.area == titleBlockProp[0]:

                            titleBlockItems.append(item)

            db_items.extend([item for item in items if type(item) is QEngineeringLineNoTextItem])

            db_items.extend([line for line in appDocData.tracerLineNos if type(line) is QEngineeringTrimLineNoTextItem])

            db_items.extend(titleBlockItems)

        except Exception as ex:

            from AppDocData import MessageType

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

    @staticmethod

        app_doc_data = AppDocData.instance()

        path = os.path.join(app_doc_data.getCurrentProject().getTempPath(), app_doc_data.imgName + '.xml')

        resultStr = '[저장 결과]'

        for item in result.items():

from EngineeringUnknownItem import QEngineeringUnknownItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

class Source:

    """ This is Source class """

    def __init__(self, source):

        if type(source) is np.ndarray:

            self.source = Image.fromarray(source)

            self.source = Image.fromqimage(source)

        elif type(source) is QPixmap:

            self.source = Image.fromqpixmap(source)

    '''

        @history    2018.05.18  Jeongwoo    When Parameter [rect] is None, return whole image

    '''

        if rect is not None:

            return self.source.copy().crop((rect.left(), rect.top(), rect.right(), rect.bottom()))

        else:

            return self.source.copy()

        image = ImageQt(self.getPyImageOnRect(rect))

        return image.convertToFormat(QImage.Format_RGBA8888)

class Drawing:

    '''

        @brief  construction

        @author humkyung

        @date   2018.07.07

    '''

    def __init__(self, uid, name, datetime):

        import uuid

        app_doc_data = AppDocData.instance()

        self.width = 0

        self.height = 0

    def __del__(self):

        """ destructor """

        @author humkyung

        @date   2018.07.07

    '''

    @property

    def attrs(self):

        return self._attrs

        @author humkyung

        @date   2018.07.07

    '''

    @attrs.setter

    def attrs(self, value):

        self._attrs = value

        self.width, self.height = image.size

        self.currentPidSource = Source(image)

    '''

        @brief  set attribute

        @author humkyung

        @date   2018.07.07

    '''

    def setAttr(self, name, value):

        attrs = [attr for attr in self._attrs if attr[0] == name]

        if attrs:

    def from_database(self):

        """ load all components of drawing """

        items = []

        tracer_line_nos = []

        app_doc_data = AppDocData.instance()

                if item: items.append(item)

            # parse texts

                item = QEngineeringTextItem.from_database(text)

                if item:

                    item.uid = text['UID']

                    items.append(item)

            # note

                item = QEngineeringTextItem.from_database(note)

                if item is not None:

                    item.uid = note['UID']

                    items.append(item)

                item = QEngineeringLineItem.from_database(line)

                if item: items.append(item)

                item = QEngineeringUnknownItem.from_database(unknown)

                if item: items.append(item)

                line_no = QEngineeringLineNoTextItem.from_database(component)

                if type(line_no) is QEngineeringLineNoTextItem:

                    runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                        line_run.owner = line_no

                        line_no.runs.append(line_run)

                tracer_line_no = QEngineeringTrimLineNoTextItem()

                tracer_line_no.uid = uuid.UUID(component['UID'])

                            matches[0].owner = tracer_line_no

                            line_run.items.append(matches[0])

                tracer_line_no.runs.append(line_run)

                tracer_line_nos.append(tracer_line_no)

                item = QEngineeringVendorItem.from_database(component)

                if item: items.append(item)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

        finally:

    def export(self, path):

        """ save items of drawing to given xml file """

        import XmlGenerator as xg

        xg.writeXmlOnScene(path, self.width, self.height, items, tracer_line_nos)

    def transfer(self, database):

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from INSTRUMENT_DATA_LIST where PNID_NO=?')

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from PipeRuns where Drawings_UID=(select UID from Drawings where Name=?)')

                cursor.execute(sql, (self.name,))

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Drawings where Name=?')

                cursor.execute(sql, (self.name,))

                for component in components:

                    sql = database.to_sql('insert into Components(UID,Drawings_UID,Symbol_UID,X,Y,Width,Height,Rotation,Area,Value,Owner,[From],[To],Connected,[Supplied By],SpecialItemTypes_UID, OriginIndex) \

                        values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)')

                for component in components:

                    pipe_runs = app_doc_data.get_pipe_runs(component['UID'])

                    for pipe_run in pipe_runs:

                        cursor.execute(sql, (pipe_run[0], pipe_run[1], pipe_run[2], pipe_run[3], pipe_run[4]))

                        pipe_run_items = app_doc_data.get_pipe_run_items(pipe_run[0])

                        for pipe_run_item in pipe_run_items:

                    connectors = app_doc_data.get_component_connectors(component['UID'])

                    for connector in connectors:

                    associations = app_doc_data.get_component_associations(component['UID'])

                    for assoc in associations:

                    attributes = app_doc_data.get_component_attributes(component['UID'])

                    for attr in attributes:

                    conn.commit()

                # Catch the exception

                print(sql)

                from App import App

    '''

    def __init__(self):

        from LineTypeConditions import LineTypeConditions

        super(self.__class__, self).__init__()

        _translate = QCoreApplication.translate

        version = QCoreApplication.applicationVersion()

        # set title

        self.lineComboBox = QComboBox(self.toolBar)

        for condition in LineTypeConditions.items():

        self.tableWidgetInconsistency.setSortingEnabled(True)

    def eventFilter(self, source, event):

        if (event.type() == QEvent.MouseMove):

            pos = self.graphicsView.mapToScene(event.pos())

            self._label_mouse.setText('mouse pos : ({},{})'.format(round(pos.x()), round(pos.y())))

        return QWidget.eventFilter(self, source, event)

    def closeEvent(self, event):

        AppDocData.instance().clear()

    def inconsistencyTableKeyPressEvent(self, event):

        try:

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

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

    '''

        @brief      action save click event

        @author     kyouho

    '''

    def actionSaveCliked(self):

        from EngineeringAbstractItem import QEngineeringAbstractItem

        from SaveWorkCommand import SaveWorkCommand

        try:

                self.showImageSelectionMessageBox()

                return

            items = self.graphicsView.scene.items()

            for item in items:

                if issubclass(type(item), QEngineeringAbstractItem):

                    if issubclass(type(item), QEngineeringTextItem):

            itemTypes = []

            for item in items:

            self._save_work_cmd.finished.connect(self.save_finished)

            self._save_work_cmd.start()

        except Exception as ex:

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

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

    def save_finished(self):

        """reload drawing list"""

        self._save_work_cmd.show_progress.emit(100)

        QMessageBox.about(self.graphicsView, self.tr('Information'), self._save_work_cmd.resultStr)

        self.load_drawing_list()

    '''

        @brief      refresh resultPropertyTableWidget

        @author     kyouho

        self.graphicsView.useDefaultCommand()

        self.graphicsView.zoomImageInit()

    def onConvertPDFToImage(self):

        """

        @brief      convert to selected pdf to image

    def onOpenImageDrawing(self, path=None):

        from Drawing import Drawing

        try:

            app_doc_data = AppDocData.instance()

            project = app_doc_data.getCurrentProject()

            self.path = self.graphicsView.loadImageFromFile(project.getDrawingFilePath(),

                try:

                    self.show_Progress_bar()

                    # Load data

                    path = os.path.join(app_doc_data.getCurrentProject().getTempPath(), app_doc_data.imgName + '.xml')

                    configs = app_doc_data.getConfigs('Data Load', 'Xml First')

                        self.loadRecognitionResultFromXml(path)

                    else:

                        self.load_drawing(app_doc_data.activeDrawing)

                finally:

                    if hasattr(self, 'progress'):

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

except ImportError:

    try:

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

    except ImportError:

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

import shapely

from LineTypeConditions import LineTypeConditions

class QEngineeringLineItem(QGraphicsLineItem, QEngineeringAbstractItem):

    """ This is engineering line item """

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

                    humkyung 2018.06.21 add vertices to parameter

    '''

    def __init__(self, vertices=[], thickness=None, parent=None, uid=None):

        import uuid

        from EngineeringConnectorItem import QEngineeringConnectorItem

            self.uid = uuid.uuid4() if uid is None else uuid.UUID(uid)

            self.thickness = thickness

            self._owner = None

            self._flowMark = None

            configs = AppDocData.instance().getConfigs('Line', 'Default Type')

            self._lineType = None

            self._properties = \

                }

            self.setAcceptHoverEvents(True)

            self.setAcceptTouchEvents(True)

            if vertices:

                self.setLine(vertices[0][0], vertices[0][1], vertices[1][0], vertices[1][1])

                index = 0

                for vertex in vertices:

                    connector.setPos(vertex)

                    connector.setParentItem(self)

                    # connector의 connectPoint, sceneConnectPoint를 vertex로 함 추후 좀 알아봐서 수정 필요

                    connector.sceneConnectPoint = vertex

                    # add connector move able

                    connector.setAcceptTouchEvents(True)

                    connector.transfer.onPosChanged.connect(self.onConnectorPosChaned)

                    index = index + 1

                self.update_arrow()

                self.setToolTip(tooltip)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

    def __str__(self):

        """ getter of flow mark """

        import uuid

            if prop.is_selectable and type(value) is uuid.UUID and self.scene():

                matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(value)]

                if matches: self._properties[prop] = matches[0]

            if prop.Expression: self._properties[prop] = eval(prop.Expression)

        return self._properties

    def set_property(self, property, value):

        """ set property with given value """

        if issubclass(type(value), QEngineeringAbstractItem): self.add_assoc_item(value, 0)

        if matches: self._properties[matches[0]] = value

    def prop(self, name):

        """ return the value of given property with name """

        if matches: return matches[0][1]

        return None

    def Size(self):

        """ always return None """

        return None

    @property

    def EvaluatedSize(self):

        from EngineeringReducerItem import QEngineeringReducerItem

                at = matches[0].items.index(self)

                upstream = matches[0].items[:at]

                upstream.reverse()

                for item in upstream:

                    if type(item) is QEngineeringReducerItem:

                            if item.MainSubSize: return item.MainSubSize[0]

                        elif item.connectors[1].connectedItem is prev:  ### Sub Size

                            if item.MainSubSize: return item.MainSubSize[1]

                prev = self

                for item in downstream:

                    if type(item) is QEngineeringReducerItem:

                            if item.MainSubSize: return item.MainSubSize[0]

                        elif item.connectors[1].connectedItem is prev:  ### Sub Size

                            if item.MainSubSize: return item.MainSubSize[1]

                if 'Drain' == matches[0].Type:

                    from AppDocData import AppDocData

                    return AppDocData.instance().drain_size

            return self.owner.Size

        return None

        @author humkyung

        @date   2018.05.10

    '''

    @property

    def owner(self):

        import uuid

        if self._owner and type(self._owner) is uuid.UUID:

            matches = [x for x in self.scene().items() if hasattr(x, 'uid') and str(x.uid) == str(self._owner)]

            if matches: self._owner = matches[0]

        if type(self._owner) is not uuid.UUID and type(self._owner) is not str:

            return self._owner

        else:

        @date   2018.05.10

        @history    2018.05.17  Jeongwoo    Add Calling setColor

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

        @author humkyung

        @date   2018.06.21

    '''

    @property

    def flowMark(self):

        return self._flowMark

        @author humkyung

        @date   2018.06.21

    '''

    @flowMark.setter

    def flowMark(self, value):

        self._flowMark = value

        @author humkyung

        @date   2018.06.27

    '''

    @property

    def lineType(self):

        return self._lineType

    '''

        @brief  setter of lineType

        @author humkyung

        @date   2018.06.27

    '''

    @lineType.setter

    def lineType(self, value):

        from AppDocData import AppDocData

        docData = AppDocData.instance()

        configs = docData.getLineTypeConfig(self._lineType)

        if configs:

            _pen.setWidth(configs[2])

            _pen.setStyle(configs[3])

            self.setPen(_pen)

    '''

        @brief  clone an object

    '''

    def clone(self):

        clone = QEngineeringLineItem()

        #    clone._pol.append(QPointF(vertex[0], vertex[1]))

        clone.buildItem()

        clone.isCreated = self.isCreated

        @author humkyung

        @date   2018.04.16

    '''

    def startPoint(self):

        at = self.line().p1()

        return (at.x(), at.y())

        @author humkyung

        @date   2018.04.16

    '''

    def endPoint(self):

        at = self.line().p2()

        return (at.x(), at.y())

        @author humkyung

        @date   2018.04.14

    '''

    def dotProduct(self, lhs, rhs):

    '''

        @brief  distance between line and point

        @author humkyung

        @date   2018.04.16

    '''

    def distanceTo(self, pt):

        from shapely.geometry import Point, LineString

        @author humkyung

        @date   2018.04.21

    '''

    def perpendicular(self):

        import math

        dx = self.endPoint()[0] - self.startPoint()[0]

        dy = self.endPoint()[1] - self.startPoint()[1]

        dx /= length

        dy /= length

    '''

        @brief  return angle of line in radian

        @author humkyung

        @date   2018.04.22

    '''

    def angle(self):

        import math

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

    '''

        @brief  return length of line

        @author humkyung

        @date   2018.05.08

    '''

    def length(self):

        import math

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

    '''

        @brief  check if line is horizontal

        @author humkyung

        @date   2018.04.27

    '''

    def isHorizontal(self):

        import math

        @author humkyung

        @date   2018.04.27

    '''

    def isVertical(self):

        import math

        @history    Jeongwoo 2018.05.15 Add normalize

                    Jeongwoo 2018.05.16 Add length == 0 check

    '''

    def intersection(self, line):

        import math

        from shapely.geometry import Point, LineString

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        if length == 0:

            return None

        dx /= length

        dy /= length

        rhs = LineString(line)

        return lhs.intersection(rhs)

        import math

        try:

            angle = self.getAngle(rhs)

            if (angle == 0) or (angle == math.pi): return True

        except ZeroDivisionError:

        @history    Jeongwoo 18.05.15 Add check pt's type

                    Jeongwoo 18.05.16 Add length == 0 check

    '''

    def is_connectable(self, line, toler=20):

        import math

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        if length == 0:

            return False

        dx /= length

        dy /= length

        pt = self.intersection(extendedLine)

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

        @date       2018.06.26

        @history    humkyung 2018.07.03 allow item to be line or symbol

    '''

    def is_connected(self, item, at=QEngineeringAbstractItem.CONNECTED_AT_PT):

        """ check if given item is connected to self """

        return len(_connectors) > 0

    '''

        @author     kyouho

        @date       2018.07.25

    '''

        import math

        from SymbolSvgItem import SymbolSvgItem

                for i in range(len(pts)):

                    dx = pts[i][0] - selected[0]

                    dy = pts[i][1] - selected[1]

                        self.setLine(line)

                        self.update()

                        break

                elif endPoint[0] == connector2Point[0] and endPoint[1] == connector2Point[1]:

                    self.connectors[1].connectedItem = item

    '''

        @brief      arrange vertex order

        @author     humkyung

        @date       2018.07.04

    '''

    def arrangeVertexOrder(self, arranged):

        import math

                index += 1

                dx = _pt[0] - pt[0]

                dy = _pt[1] - pt[1]

                if minDist is None or dist < minDist:

                    minDist = dist

                    indexed = index

        if indexed == 1 or indexed == 4:

            self.reverse()

        @date       2018.06.25

        @history    humkyung 2018.06.27 check line type

    '''

    def isExtendable(self, line, toler=5):

        import math

        from SymbolSvgItem import SymbolSvgItem

        if self.lineType == line.lineType:

            if self.isHorizontal() and line.isHorizontal():

                return (flag and (math.fabs(self.startPoint()[1] - line.startPoint()[1]) < toler))

            elif self.isVertical() and line.isVertical():

                return (flag and (math.fabs(self.startPoint()[0] - line.startPoint()[0]) < toler))

        return False

    def is_external_point(self, pt):

        """ check given pt is located outside of line """

        import math

            dx = self.endPoint()[0] - self.startPoint()[0]

            dy = self.endPoint()[1] - self.startPoint()[1]

            lineLength = math.sqrt(dx * dx + dy * dy)

            dx = pt.x - self.startPoint()[0]

            dy = pt.y - self.startPoint()[1]

            length = math.sqrt(dx * dx + dy * dy)

            return False

        except Exception as ex:

            from AppDocData import MessageType

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

    '''

        @history    humkyung 2018.05.08 check if line is possible to be connected

                    Jeongwoo 2018.05.15 Split if-statement and Connect each symbol and line

    '''

    def connect_if_possible(self, obj, toler=20):

        """ connect line or symbol is able to be connected and return symbol or line connected to connectors """

        """ this method not update item's position """

        res = []

        endPt = self.endPoint()

        try:

                    pt = obj.connectors[i].sceneConnectPoint

                    if (Point(startPt[0], startPt[1]).distance(Point(pt[0], pt[1])) < toler):

                        if self.connectors[0].connectedItem is None and obj.connectors[i].connectedItem is None:

                            obj.connectors[i].connect(self)

                            res.append(obj)

                            res.append(obj.connectors[i].sceneConnectPoint)

                _startPt = obj.startPoint()

                _endPt = obj.endPoint()

                if self.distanceTo(_startPt) < toler:

                        self.connectors[0].connect(obj)

                        obj.connectors[0].connect(self)

                        res.append(obj)

                        self.connectors[1].connect(obj)

                        obj.connectors[0].connect(self)

                        res.append(obj)

                    else:

                        obj.connectors[1].connect(self, at=QEngineeringAbstractItem.CONNECTED_AT_BODY)

        except Exception as ex:

            from AppDocData import MessageType

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

        return res

        @author     kyouho

        @date       2018.08.30

    '''

    def disconnectedItemAtConnector(self, connector):

        for conn in self.connectors:

            if conn.isOverlapConnector(connector):

        """ reverse if from is connected to second connector """

        if not _from: raise ValueError

    '''

        @brief      reverse line

        @author     humkyung

        @date       2018.07.03

    '''

    def reverse(self):

        line = self.line()

        self.setLine(QLineF(line.p2(), line.p1()))

        @date       2018.05.08

        @history    2018.05.24  Jeongwoo    Modifying Draw Flow Arrow

    '''

    def addFlowArrow(self):

        import numpy as np

        import cv2

        from shapely.geometry import Point

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from AppDocData import AppDocData

        try:

            docData = AppDocData.instance()

            area = docData.getArea('Drawing')

            docData = AppDocData.instance()

            area = docData.getArea('Drawing')

            img = np.array(AppDocData.instance().getCurrentPidSource().getPyImageOnRect(rect))

            imgLine = cv2.threshold(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 127, 255, cv2.THRESH_BINARY)[1]

            # remove noise

            imgLine = cv2.bitwise_not(imgLine)

            if contours:

                contours = sorted(contours, key=cv2.contourArea, reverse=True)

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

                    # DEBUG - display flow arrow area

                    '''

                    # up to here

                    edges = cv2.Canny(imgArrowMark, 50, 150, apertureSize=3)

                    ####### HoughLinesP

                    if lines is not None:

                                dx = x2 - x1

                                dy = y2 - y1

                                selected = line

                                if maxLength is None or length > maxLength:

                                    maxLength = length

                                    selected = line

                        for x1, y1, x2, y2 in selected:

                            dx = math.fabs(x2 - x1)

                            dy = math.fabs(y2 - y1)

                            dx /= length

                            dy /= length

                            dist1 = self.distanceTo((rect.left() + x + x1, rect.top() + y + y1))

                            dist2 = self.distanceTo((rect.left() + x + x2, rect.top() + y + y2))

                                _start = (rect.left() + x + x1, rect.top() + y + y1)

                                _end = (rect.left() + x + x2, rect.top() + y + y2)

                            else:

                                _start = (rect.left() + x + x2, rect.top() + y + y2)

                                _end = (rect.left() + x + x1, rect.top() + y + y1)

                            # DEBUG display detected line

                            '''

                            poly = QEngineeringPolylineItem()

                            dist1 = Point(startPt[0], startPt[1]).distance(Point(_start[0], _start[1]))

                            dist2 = Point(startPt[0], startPt[1]).distance(Point(_end[0], _end[1]))

                            if dist1 > dist2:

                                self.reverse()

                        '''

                        center = [(startPt[0]+endPt[0])*0.5, (startPt[1]+endPt[1])*0.5]

                        arrow = QEngineeringFlowArrowItem(center, direction)

                else:

                    pass

        except Exception as ex:

            from AppDocData import MessageType

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

    '''

        @date   2018.04.22

        @history    kyouho  2018.07.24  add symbol angle, transform rotateRadians(-angle -> angle)

    '''

    def insertSymbol(self, symbol, pos):

        import math

        from shapely.geometry import Point

        from shapely import affinity

        vec = self.perpendicular()

        origin = self.intersection(line)

        transform = QTransform()

        transform.translate(origin.x, origin.y)

        transform.rotateRadians(-angle)

        transform.translate(-symbol.symbolOrigin[0], -symbol.symbolOrigin[1])

        symbol.setTransform(transform)

        symbol.angle = round(angle, 2)

            for i in range(len(symbol.connectors)):

            dx1 = symbol.connectors[0].sceneConnectPoint[0] - self.startPoint()[0]

            dy1 = symbol.connectors[0].sceneConnectPoint[1] - self.startPoint()[1]

            dx2 = symbol.connectors[1].sceneConnectPoint[0] - self.startPoint()[0]

            dy2 = symbol.connectors[1].sceneConnectPoint[1] - self.startPoint()[1]

            if length1 < length2:

                processLine = QEngineeringLineItem([symbol.connectors[1].sceneConnectPoint, self.endPoint()])

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

                self.setLine(line)

                self.connectors[1].connectedItem = symbol

                processLine.connectors[1].connectedItem = self.connectors[1].connectedItem

                self.scene().addItem(processLine)

                self.setLine(line)

                self.connectors[1].connectedItem = symbol

                symbol.connectors[0].connectedItem = processLine

                symbol.connectors[1].connectedItem = self

            self.joinTo(symbol)

            processLine.joinTo(symbol)

            self.update()

        symbol.loc = [origin.x - symbol.symbolOrigin[0], origin.y - symbol.symbolOrigin[1]]

        symbol.size = [symbol.boundingRect().width(), symbol.boundingRect().height()]

        self.scene().addItem(symbol)

    '''

        @brief  redraw symbol

        @author kyouho

        @date   2018.07.25

    '''

    def reDrawLine(self, symbol, point):

        for index in range(len(self.connectors)):

            if self.connectors[index].connectedItem == symbol:

                if index == 0:

                    line = QLineF(QPointF(point[0], point[1]), self.line().p2())

                    self.setLine(line)

                    self.connectors[0].setPos([point[0], point[1]])

                else:

                    line = QLineF(self.line().p1(), QPointF(point[0], point[1]))

                    self.setLine(line)

                    self.connectors[1].setPos([point[0], point[1]])

        ## startPoint에 symbol

        #    if self.startPoint()[0] == symbol.connectors[0].sceneConnectPoint[0] and self.startPoint()[1] == symbol.connectors[0].sceneConnectPoint[1]:

        #        line = QLineF(QPointF(changedConnPoint1[0], changedConnPoint1[1]), self.line().p2())

        #        self.setLine(line)

        #        line = QLineF(QPointF(changedConnPoint2[0], changedConnPoint2[1]), self.line().p2())

        #        self.setLine(line)

        ## endPoint에 symbol

        #    if self.endPoint()[0] == symbol.connectors[0].sceneConnectPoint[0] and self.endPoint()[1] == symbol.connectors[0].sceneConnectPoint[1]:

        #        line = QLineF(self.line().p1(), QPointF(changedConnPoint1[0], changedConnPoint1[1]))

        #        self.setLine(line)

        @author humkyung

        @date   2018.04.23

    '''

    def removeSymbol(self, symbol):

        import math

        if 2 == len(symbol.connectors):  # 2-way component

            pts = []

            pts.append(self.startPoint())

            pts.append(self.endPoint())

            end = None

            maxDist = None

            for i in range(len(pts)):

                    dx = pts[i][0] - pts[j][0]

                    dy = pts[i][1] - pts[j][1]

                    if maxDist is None:

                        maxDist = dist

                        start = pts[i]

                        start = pts[i]

                        end = pts[j]

            line = QLineF(QPointF(start[0], start[1]), QPointF(end[0], end[1]))

            self.setLine(line)

            self.update()

    def validate(self):

                    errors.append(error)

                # check line to symbol

                    matches = [conn for conn in connector.connectedItem.connectors if conn.connectedItem is self]

                    # check if two items are connected each other

                    if not matches:

                        indices = [0, 0]

                        indices[0] = 1 if QPointF(center[0], center[1]) == self.line().p1() else 2

                        if matches:

                            error = SymbolSvgItem.createItem('Error', dataPath)

                            error.setPosition(connector.center())

                            error.parent = self

                errors.append(error)

        except Exception as ex:

            from AppDocData import MessageType

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

        return errors

    '''

        @author humkyung

        @date   2018.07.05

    '''

    def update_line_type(self):

        import uuid

        from LineTypeConditions import LineTypeConditions

        try:

            while pool:

                obj = pool.pop()

                visited.append(obj)

                """ connected items """

                """ connected lines at point """

                """ add items not in 'connected' to items list """

                items.extend([item for item in connected if item not in lines])

                """ add items not visited to pool """

                    self.lineType = condition.name

                    break

        except Exception as ex: