HYTOS

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

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

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

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from SymbolSvgItem import SymbolSvgItem

        from GraphicsPolylineItem import QGraphicsPolylineItem

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

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

                    self.imageViewer.scene.addItem(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:

            if self._polyline is not None:

                self.onSuccess.emit()

        elif 'mouseMoveEvent' == param[0]:

            if self._polyline is not None:

                # get connection point near by mouse point

                pt = (param[2].x(), param[2].y())

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

                if (item is not None) and (type(item) is SymbolSvgItem):

                    connPt = item.getConnectionPointCloseTo(pt, 5)

                    if connPt is not None: pt = connPt

                elif (item is not None) and (type(item) is QEngineeringConnectorItem):

                    pt = item.center()

                # up to here

                if len(self._polyline._vertices) > 0:

                    dx = abs(self._polyline._vertices[-1][0] - pt[0])

                    dy = abs(self._polyline._vertices[-1][1] - pt[1])

                    if dx < dy:

                        self._polyline._pt = (self._polyline._vertices[-1][0], pt[1])

                    else:

                        self._polyline._pt = (pt[0], self._polyline._vertices[-1][1])

                else:

                    self._polyline._pt = pt

                self._polyline.update()

        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

import GraphicsPolylineItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineItem import QEngineeringLineItem

    from EngineeringLineItem import QEngineeringLineItem

import GraphicsPolylineItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineItem import QEngineeringLineItem

        from EngineeringLineItem import QEngineeringLineItem

import PlaceLineCommand

from GraphicsPolylineItem import QGraphicsPolylineItem

from EngineeringLineItem import QEngineeringLineItem

        self.actionLine.triggered.connect(self.onPlaceLine)

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

        @brief      create a line

        @author     humkyung

        @history    Jeongwoo 2018.05.10 Change method for Checkable action

    def onPlaceLine(self):        

        self.actionLine.setChecked(True)

        if not hasattr(self.actionLine, 'tag'):

            self.actionLine.tag = PlaceLineCommand.PlaceLineCommand(self.graphicsView)

            self.actionLine.tag.onSuccess.connect(self.onLineCreated)

            self.actionLine.tag.onRejected.connect(self.onCommandRejected)

        self.graphicsView.command = self.actionLine.tag

        @brief      add created lines to scene

        @author     humkyung

        @date       2018.07.23

    '''

    def onLineCreated(self):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        try:

            count = len(self.actionLine.tag._polyline._vertices)

            if count > 1:

                items = []

                lineType = self.lineComboBox.currentText()

                for index in range(count - 1):

                    start = self.actionLine.tag._polyline._vertices[index]

                    end  = self.actionLine.tag._polyline._vertices[index + 1]

                    lineItem = QEngineeringLineItem(vertices=[start, end])

                    lineItem.transfer.onRemoved.connect(self.itemRemoved)

                    lineItem.buildItem()

                    lineItem.lineType = lineType

                    if items:

                        lineItem.conns[0] = items[-1]

                        items[-1].conns[1] = lineItem

                    else:

                        pt = lineItem.startPoint()

                        selected = self.graphicsView.scene.itemAt(QPointF(pt[0], pt[1]), QTransform())

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

                            lineItem.conns[0] = selected.parent

                    items.append(lineItem)

                    self.graphicsView.scene.addItem(lineItem)

                pt = items[-1].endPoint()

                selected = self.graphicsView.scene.itemAt(QPointF(pt[0], pt[1]), QTransform())

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

                    items[-1].conns[1] = selected.parent

        finally:

            self.graphicsView.scene.removeItem(self.actionLine.tag._polyline)

            self.actionLine.tag.reset()

    '''

        @brief      refresh scene

        @author     humkyung

        @date       2018.07.23

    '''

    def onCommandRejected(self, cmd):

        try:

            if cmd is self.actionLine.tag:

                self.graphicsView.scene.removeItem(self.actionLine.tag._polyline)

                self.graphicsView.scene.update()

                self.actionLine.tag.reset()

                self.actionLine.setChecked(False)

        finally:

            self.graphicsView.useDefaultCommand()

    '''

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

                    item.transfer.onRemoved.connect(self.itemRemoved)

        from EngineeringLineItem import QEngineeringLineItem

                    item[0].transfer.onRemoved.connect(self.itemRemoved)

                        item.transfer.onRemoved.connect(self.itemRemoved)

                    item.transfer.onRemoved.connect(self.itemRemoved)

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineItem import QEngineeringLineItem

        @brief      key press event

        @author     Jeongwoo

        @date       2018.??.??

        @history    send escape key event to command

        try:

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

                self.isPressCtrl = True

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

                for item in self.scene.selectedItems():

                    item.transfer.onRemoved.emit(item)

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

                if self.command is not None:

                    self.command.execute(['keyPressEvent', event])

            QGraphicsView.keyPressEvent(self, event)

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

	[6] �� ������ EngineeringLineItem ���� ���� �� QtImageViewer ���� �߰�

from EngineeringLineItem import QEngineeringLineItem

        @brief      return center of connector

        @author     humkyung

        @date       2018.07.23

    '''

    def center(self):

        pt = self.sceneBoundingRect().center()

        return (pt.x(), pt.y())

    '''

# coding: utf-8

import sys

import os.path

import copy

import cv2

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QColor, QBrush, QPen, QTransform

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsPathItem

except ImportError:

    try:

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

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

    except ImportError:

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

from GraphicsPolylineItem import QGraphicsPolylineItem

from QGraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

import shapely

class QEngineeringLineItem(QGraphicsPolylineItem):

    '''

        @history    2018.05.11  Jeongwoo    Make Comments self.setPen()

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

                    humkyung 2018.06.21 add vertices to parameter

    '''

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

        QGraphicsPolylineItem.__init__(self, parent)

        self.isCreated = True 

        self.conns = [None, None]

        self._owner = None

        self._flowMark = None

        self._lineType = 'Primary'

        # add vertex

        for vertex in vertices:

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

        # up to here

        self.setFlags(QGraphicsItem.ItemIsSelectable|QGraphicsItem.ItemIsFocusable)

        self.setAcceptHoverEvents(True)

        self.setAcceptTouchEvents(True)

        ptStart = self.startPoint()

        ptEnd = self.endPoint()

        self.setToolTip('({},{})-({},{})'.format(ptStart[0], ptStart[1], ptEnd[0], ptEnd[1]))

    '''

        @breif  getter owner

        @author humkyung

        @date   2018.05.10

    '''

    @property

    def owner(self):

        return self._owner

    '''

        @brief  setter owner

        @author humkyung

        @date   2018.05.10

        @history    2018.05.17  Jeongwoo    Add Calling setColor

    '''

    @owner.setter

    def owner(self, value):

        self._owner = value

        if self._owner is None:

            self._color = self.DEFAULT_COLOR

        self.setColor(self._color)

    '''

        @brief  getter flow mark

        @author humkyung

        @date   2018.06.21

    '''

    @property

    def flowMark(self):

        return self._flowMark

    '''

        @brief  setter flow mark

        @author humkyung

        @date   2018.06.21

    '''

    @flowMark.setter

    def flowMark(self, value):

        self._flowMark = value

    '''

        @brief  getter of lineType

        @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

        self._lineType = value

        docData = AppDocData.instance()

        config = docData.getLineTypeConfig(self._lineType)

        _pen = self.pen() 

        _pen.setWidth(config[1])

        _pen.setStyle(config[2])

        self.setPen(_pen)

        self.update()

    '''

        @brief  clone an object

    '''

    def clone(self):

        clone = QEngineeringLineItem()

        clone._vertices = copy.deepcopy(self._vertices)

        for vertex in clone._vertices:

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

        clone.buildItem()

        clone.isCreated = self.isCreated

        return clone

    '''

        @brief  dot product of given two vectors

        @author humkyung

        @date   2018.04.14

    '''

    def dotProduct(self, lhs, rhs):

        return sum([lhs[i]*rhs[i] for i in range(len(lhs))])

    '''

        @brief  distance between line and point

        @author humkyung

        @date   2018.04.16

    '''

    def distanceTo(self, pt):

        from shapely.geometry import Point, LineString

        startPt = self.startPoint()

        endPt = self.endPoint()

        line = LineString([(startPt[0], startPt[1]), (endPt[0], endPt[1])])

        dist = line.distance(Point(pt[0], pt[1]))

        return dist

    '''

        @brief  return perpendicular vector

        @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,dy = -dy,dx

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

        dx /= length

        dy /= length

        return (dx,dy)

    '''

        @brief  return angle of line in radian

        @author humkyung

        @date   2018.04.22

    '''

    def angle(self):

        import math

        startPt = self.startPoint()

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        dot = self.dotProduct((1,0), (dx, dy))

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

        return math.acos(dot/length)

    '''

        @brief  return length of line

        @author humkyung

        @date   2018.05.08

    '''

    def length(self):

        import math

        startPt = self.startPoint()

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        return math.sqrt(dx*dx + dy*dy)

    '''

        @brief  check if line is horizontal

        @author humkyung

        @date   2018.04.27

    '''

    def isHorizontal(self):

        import math

        startPt = self.startPoint()

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        return math.fabs(dx) > math.fabs(dy)

    '''

        @brief  check if line is vertical 

        @author humkyung

        @date   2018.04.27

    '''

    def isVertical(self):

        import math

        startPt = self.startPoint()

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

        return math.fabs(dy) > math.fabs(dx)

    '''

        @brief  get intersection point between this and given line

        @author humkyung

        @date   2018.04.21

        @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

        startPt = self.startPoint()

        endPt = self.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

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

        if length == 0:

            return None

        dx /= length

        dy /= length

        lhs = LineString([(startPt[0] - dx*20, startPt[1] - dy*20), (endPt[0] + dx*20, endPt[1] + dy*20)])

        rhs = LineString(line)

        return lhs.intersection(rhs)

    '''

        @brief      check if two lines are connectable

        @author     humkyung

        @date       2018.05.12

        @history    Jeongwoo 18.05.15 Add check pt's type

                    Jeongwoo 18.05.16 Add length == 0 check

    '''

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

        import math

        startPt = line.startPoint()

        endPt = line.endPoint()

        dx = endPt[0] - startPt[0]

        dy = endPt[1] - startPt[1]

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

        if length == 0:

            return False

        dx /= length

        dy /= length

        extendedLine = [(startPt[0] - dx*toler, startPt[1] - dy*toler), (endPt[0] + dx*toler, endPt[1] + dy*toler)]

        pt = self.intersection(extendedLine)

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

    '''

        @brief      check if line and given item is jointable

        @author     humkyung

        @date       2018.06.26

        @history    humkyung 2018.07.03 allow item to be line or symbol

    '''

    def isJointed(self, item, toler=5):

        import math

        from SymbolSvgItem import SymbolSvgItem

        lhs = [self.startPoint(), self.endPoint()]

        if type(item) is QEngineeringLineItem:

            rhs = [item.startPoint(), item.endPoint()]

        elif issubclass(type(item), SymbolSvgItem):

            rhs = item.connPts

        else:

            rhs = []

        for pt in lhs:

            for _pt in rhs:

                dx = _pt[0] - pt[0]

                dy = _pt[1] - pt[1]

                if math.sqrt(dx*dx + dy*dy) < toler:

                    return True

        return False

    '''

        @brief      arrange vertex order

        @author     humkyung

        @date       2018.07.04

    '''

    def arrangeVertexOrder(self, arranged):

        import math

        lhs = [arranged.startPoint(), arranged.endPoint()]

        rhs = [self.startPoint(), self.endPoint()]

        index = 0

        indexed = 0

        minDist = None

        for pt in lhs:

            for _pt in rhs:

                index += 1

                dx = _pt[0] - pt[0]

                dy = _pt[1] - pt[1]

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

                if minDist is None or dist < minDist:

                    minDist = dist

                    indexed = index

        if indexed == 1 or indexed == 4:

            self.reverse()

    '''

        @brief      check if two lines are extendable

        @author     humkyung

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

                flag = (line.conns[0] is not None and issubclass(type(line.conns[0]), SymbolSvgItem)) or (line.conns[1] is not None and issubclass(type(line.conns[1]), SymbolSvgItem))

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

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

                flag = (line.conns[0] is not None and issubclass(type(line.conns[0]), SymbolSvgItem)) or (line.conns[1] is not None and issubclass(type(line.conns[1]), SymbolSvgItem))

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

        return False

    '''

        @brief      connect line and symbol is able to be connected and return symbol

        @author     humkyung

        @date       2018.04.16

        @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 connectIfPossible(self, obj, toler):

        from shapely.geometry import Point

        from SymbolSvgItem import SymbolSvgItem

        res = []

        startPt = self.startPoint() 

        endPt = self.endPoint()

        if issubclass(type(obj), SymbolSvgItem):

            for i in range(len(obj.connPts)):

                pt = obj.connPts[i]

                if len(obj.conns) <= i: obj.conns.append(None)

                if (self.conns[0] is None) and (Point(startPt[0], startPt[1]).distance(Point(pt[0], pt[1])) < toler):

                    self.conns[0] = obj 

                    obj.conns[i] = self

                    res.append(obj)

                if (self.conns[1] is None) and (Point(endPt[0], endPt[1]).distance(Point(pt[0], pt[1])) < toler):

                    self.conns[1] = obj

                    obj.conns[i] = self

                    res.append(obj)

        elif type(obj) is QEngineeringLineItem:

            _startPt = obj.startPoint()

            _endPt = obj.endPoint()

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

                self.conns[0] = obj

                obj.conns[0] = self

                res.append(obj)

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

                self.conns[0] = obj

                obj.conns[1] = self

                res.append(obj)

            if((Point(endPt[0], endPt[1]).distance(Point(_startPt[0], _startPt[1])) < toler)):

                self.conns[1] = obj

                obj.conns[0] = self

                res.append(obj)

            if ((Point(endPt[0], endPt[1]).distance(Point(_endPt[0], _endPt[1])) < toler)):

                self.conns[1] = obj

                obj.conns[1] = self

                res.append(obj)

        return res

    '''

        @brief      reverse line

        @author     humkyung

        @date       2018.07.03

    '''

    def reverse(self):

        clone = self._pol.toPolygon()

        self._pol.clear()

        for idx in reversed(range(clone.count())):

            self._pol.append(clone.at(idx))

    '''

        @brief      add flow arrow

        @author     humkyung

        @date       2018.05.08

        @history    2018.05.24  Jeongwoo    Modifying Draw Flow Arrow

    '''

    def addFlowArrow(self):

        import numpy as np

        import cv2

        import math

        import sys

        global src

        from shapely.geometry import Point

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from AppDocData import AppDocData

        try:

            docData = AppDocData.instance()

            area = docData.getArea('Drawing')

            startPt = self.startPoint()

            endPt = self.endPoint()

            length = self.length()

            direction = [(endPt[0] - startPt[0]) / length, (endPt[1] - startPt[1]) / length]

            left = min(startPt[0], endPt[0])

            top = min(startPt[1], endPt[1])

            right = max(startPt[0], endPt[0])

            bottom = max(startPt[1], endPt[1])

            rect = None

            if self.isVertical():

                rect = QRectF(left - 10, top, (right - left) + 20, (bottom - top))

            else:

                rect = QRectF(left, top - 10, (right - left), (bottom - top) + 20)

            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)

            imgLine = cv2.erode(imgLine, np.ones((10, 10), np.uint8))

            image, contours, hierarchy = cv2.findContours(imgLine, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

            if contours:

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

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

                if w > 10 and w < 100 and h > 10 and h < 100:   # check arrow mark size

                    imgArrowMark = imgLine[y:y+h, x:x+w]

                    # DEBUG - display flow arrow area

                    '''

                    item = QGraphicsBoundingBoxItem(rect.left() + x - 10, rect.top() + y - 10, w + 20, h + 20)

                    item.isSymbol = True

                    item.angle = 0

                    item.setPen(QPen(Qt.red, 1, Qt.SolidLine))

                    item.setBrush(QBrush(QColor(255,255,0,100)))

                    self.scene().addItem(item)

                    '''

                    # up to here

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

                    lines = cv2.HoughLinesP(edges, 1, np.pi/180, 10, minLineLength=10, maxLineGap=5)

                    ####### HoughLinesP

                    if lines is not None:

                        maxLength = None

                        selected = None

                        for line in lines:

                            for x1, y1, x2, y2 in line:

                                dx = x2 - x1

                                dy = y2 - y1

                                selected = line

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

                                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)

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

                            dx /= length

                            dy /= length

                            if (self.isVertical() and (dx < 0.001 or math.fabs(dx - 1) < 0.001)) or (self.isHorizontal() and (dx < 0.001 or math.fabs(dx - 1) < 0.001)): continue 

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

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

                            if dist1 > dist2:   # point which's distance is longer would be start point

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

                            poly._pol.append(QPointF(_start[0], _start[1]))

                            poly._pol.append(QPointF(_end[0], _end[1]))

                            poly.setPen(QPen(Qt.red, 2, Qt.SolidLine))

                            poly.buildItem()

                            self.scene().addItem(poly)

                            '''

                            # up to here

                            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:

                                startPt,endPt = endPt,startPt

                                direction[0],direction[1] = -direction[0],-direction[1]

                                self.reverse()

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

                        arrow = QEngineeringFlowArrowItem(center, direction)

                        arrow.buildItem()

                        self.scene().addItem(arrow)

                        x = round(rect.left() + x - 5)

                        y = round(rect.top() + y - 5)

                        self.flowMark = ([x, y, w + 10, h + 10], None)

                else:

                    pass

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

    '''

        @breif  insert symbol

        @author humkyung

        @date   2018.04.22

    '''

    def insertSymbol(self, symbol, pos):

        import math

        from shapely.geometry import Point

        from shapely import affinity

        vec = self.perpendicular()

        line = [(pos.x() - vec[0]*20, pos.y() - vec[1]*20),(pos.x() + vec[0]*20, pos.y() + vec[1]*20)]

        origin = self.intersection(line)

        transform = QTransform()

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

        angle = self.angle()

        transform.rotateRadians(-angle)

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

        symbol.setTransform(transform)

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

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

                rotatedPt = affinity.rotate(Point(symbol.connPts[i][0] - symbol.origin[0], symbol.connPts[i][1] - symbol.origin[1]), -angle, Point(0, 0), use_radians=True)

                symbol.connPts[i] = (origin.x+rotatedPt.x, origin.y+rotatedPt.y)

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

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

            length1 = math.sqrt(dx1*dx1 + dy1*dy1)

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

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

            length2 = math.sqrt(dx2*dx2 + dy2*dy2)

            if length1 < length2:

                processLine = QEngineeringLineItem()

                processLine._pol.append(QPointF(symbol.connPts[1][0], symbol.connPts[1][1]))

                processLine._pol.append(QPointF(self.endPoint()[0], self.endPoint()[1]))

                processLine.buildItem()

                processLine.conns.append(symbol)

                processLine.conns.append(self.conns[1])

                self.scene().addItem(processLine)

                self._pol.replace(self._pol.count() - 1, QPointF(symbol.connPts[0][0], symbol.connPts[0][1]))

                self.conns[1] = symbol

                symbol.conns = []

                symbol.conns.append(self)

                symbol.conns.append(processLine)

            else:

                processLine = QEngineeringLineItem()

                processLine._pol.append(QPointF(symbol.connPts[0][0], symbol.connPts[0][1]))

                processLine._pol.append(QPointF(self.endPoint()[0], self.endPoint()[1]))

                processLine.buildItem()

                processLine.conns.append(symbol)

                processLine.conns.append(self.conns[1])

                self.scene().addItem(processLine)

                self._pol.replace(self._pol.count() - 1, QPointF(symbol.connPts[1][0], symbol.connPts[1][1]))

                self.conns[1] = symbol

                symbol.conns = []

                symbol.conns.append(processLine)

                symbol.conns.append(self)

            self.buildItem()

            self.update()

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

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

        self.scene().addItem(symbol)

        for connector in symbol.connectors:

            self.scene().addItem(connector)

    '''

        @brief  remove symbol

        @author humkyung

        @date   2018.04.23

    '''

    def removeSymbol(self, symbol):

        import math

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

            connected = symbol.conns[0] if symbol.conns[0] is not self else symbol.conns[1]

            pts = []

            pts.append(self.startPoint())

            pts.append(self.endPoint())

            pts.append(connected.startPoint())

            pts.append(connected.endPoint())

            self.scene().removeItem(connected)

            start = None

            end = None

            maxDist = None

            for i in range(len(pts)):

                for j in range(i+1,len(pts)):

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

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

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

                    if maxDist is None:

                        maxDist = dist

                        start = pts[i]

                        end = pts[j]

                    elif dist > maxDist:

                        maxDist = dist

                        start = pts[i]

                        end = pts[j]

            if (pts[0] == end) or (pts[1] == start): start,end = end,start

            self._pol.clear()

            self._pol.append(QPointF(start[0], start[1]))

            self._pol.append(QPointF(end[0], end[1]))

            self.buildItem()

            self.update()

    '''

        @brief  update line type

        @author humkyung

        @date   2018.07.05

    '''

    def updateLineType(self):

        from QEngineeringInstrumentItem import QEngineeringInstrumentItem

        if len(self.conns) == 2:

            lines = [item for item in self.conns if item is not None and type(item) is QEngineeringLineItem]

            insts = [item for item in self.conns if item is not None and type(item) is QEngineeringInstrumentItem]

            matches = [inst for inst in insts if (inst.measuredVariableCode + inst.typeModifier) not in ['FT', 'PT', 'TT', 'TI', 'TG', 'PG']]

            if matches:

                self.lineType = 'Electric'

                pool = [item for item in self.conns if item is not None and type(item) is QEngineeringLineItem]

                visited = []

                visited.extend(pool)

                while len(pool):

                    line = pool.pop()

                    line.lineType = 'Electric'

                    matches = [item for item in line.conns if item is not None and item not in visited and type(item) is QEngineeringLineItem]

                    pool.extend(matches)

                    visited.extend(matches)

            else:

                matches = [inst for inst in insts if (inst.measuredVariableCode + inst.typeModifier) in ['FT', 'PT', 'TT', 'TI', 'TG', 'PG']]

                if matches:

                    self.lineType = 'Connect To Process'

    def hoverEnterEvent(self, event):

        pass

    def hoverLeaveEvent(self, event):

        pass

    def hoverMoveEvent(self, event):

        pass

    '''

        @brief  remove item when user press delete key

        @author humkyung

        @date   2018.04.23

    '''

    def keyPressEvent(self, event): 

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

            #self.removed.emit((QGraphicsPathItem)(self))

            self.scene().removeItem(self)

    '''

        @brief  draw rect when item is selected

        @author humkyung

        @date   2018.07.07

    '''

    def drawFocusRect(self, painter):

        self.focuspen = QPen(Qt.DotLine)

        self.focuspen.setColor(Qt.black)

        self.focuspen.setWidthF(1.5)

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

        painter.setBrush(QBrush(hilightColor))

        painter.setPen(self.focuspen)

        painter.drawRect(self.boundingRect())

    '''

        @brief  override paint method

    '''

    def paint(self, painter, option, widget):

        QGraphicsPolylineItem.paint(self, painter, option, widget)

        if self.isSelected():

            self.drawFocusRect(painter)

    '''

        @brief  draw self to given image

        @author humkyung

        @date   2018.06.21

    '''

    def drawToImage(self, img, color, thickness):

        try:

            # write recognized lines to image

            ptStart = self.startPoint()

            ptEnd = self.endPoint()

            cv2.line(img, (round(ptStart[0]), round(ptStart[1])), (round(ptEnd[0]), round(ptEnd[1])), color, thickness)

            # up to here

            if self.flowMark is not None:

                x, y, w, h = self.flowMark[0]

                img[y:(y+h), x:(x+w)] = color

        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      parse xml code

        @author     humkyung

        @date       2018.06.27

    '''

    @staticmethod 

    def fromXml(node):

        item = None

        try:

            startPoint = [float(x) for x in node.find('STARTPOINT').text.split(',')]

            endPoint = [float(x) for x in node.find('ENDPOINT').text.split(',')]

            lineType = node.find('TYPE').text if node.find('TYPE') else 'Primary'

            item = QEngineeringLineItem(vertices=[startPoint, endPoint])

            item.lineType = lineType

            item.buildItem()

        except Exception as ex:

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

        return item

    '''

        @brief      generate xml code

        @author     humkyung

        @date       2018.04.23

        @history    humkyung 2018.06.27 write line type to xml

    '''

    def toXml(self):

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

        try:

            node = Element('LINE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            node.append(uidNode)

            startPt = self.startPoint()

            endPt = self.endPoint()

            startNode = Element('STARTPOINT')

            startNode.text = '{},{}'.format(startPt[0], startPt[1])

            node.append(startNode)

            endNode = Element('ENDPOINT')

            endNode.text = '{},{}'.format(endPt[0], endPt[1])

            node.append(endNode)

            typeNode = Element('TYPE')

            typeNode.text = self.lineType

            node.append(typeNode)

        except Exception as ex:

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

        return node

    '''

        @brief      Delete Line Item from scene

        @author     Jeongwoo

        @date       2018.05.29

        @history    2018.05.29  Add parameter 'self' / Make comments emit()

    '''

    def deleteLineItemFromScene(self):

        #self.removed.emit(self)

        self.scene().removeItem(self)

    '''

        @brief      Add Line Item 

        @author     Jeongwoo

        @date       2018.05.29

    '''

    def addLineItemToScene(self, scene):

        scene.addItem(self)

import sys

import os.path

import copy

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QBrush, QPen, QPolygonF, QColor

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog, QGraphicsItem, QAbstractGraphicsShapeItem, QGraphicsPathItem

except ImportError:

    try:

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

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

    except ImportError:

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

from QEngineeringAbstractItem import QEngineeringAbstractItem

class QGraphicsPolylineItem(QGraphicsPathItem, QEngineeringAbstractItem):

    onRemoved = pyqtSignal(QGraphicsItem)

    '''

        @history    2018.05.11  Jeongwoo    Declare variable self.pen

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

                    2018.05.25  Jeongwoo    Change self.pen's default color (red → blue)

    '''

    def __init__(self, uid=None, parent=None):

        import uuid

        try:

            QGraphicsPathItem.__init__(self, parent)

            QEngineeringAbstractItem.__init__(self)

            self.setFlags(QGraphicsItem.ItemIsSelectable|QGraphicsItem.ItemIsFocusable)

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

            self._vertices = []

            self.isCreated = False

            self._pt = None

            self._pol = QPolygonF()

            self._path = None

            self.setPen(QPen(Qt.blue, 4, Qt.SolidLine)) # set default pen

            self.transfer = Transfer()

        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  construct a polyline

    '''

    def process(self, param):

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

            self._vertices.append(param[2])

        elif ('mouseMoveEvent' == param[0]):

            self._pt = param[2]

        elif ('mouseReleaseEvent' == param[0]) and (param[1].button() == Qt.RightButton):

            self.isCreated = True

    '''

        @brief  clone an object

    '''

    def clone(self):

        clone = QGraphicsPolylineItem()

        clone._vertices = copy.deepcopy(self._vertices)

        clone.isCreated = self.isCreated

        return clone

    def init(self):

        self._vertices = []

        self._pol.clear()

        self._pt = None

        self.isCreated = False

    '''

        @build  build path

        @author humkyung

        @date   2018.04.23

    '''

    def buildItem(self):

        self._path = QPainterPath()

        self._path.addPolygon(self._pol)

        self.setPath(self._path)

        self.isCreated = True

    '''

        @brief  return start point

        @author humkyung

        @date   2018.04.16

    '''

    def startPoint(self):

        at = self._pol.at(0)

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

    '''

        @brief  return last point

        @author humkyung

        @date   2018.04.16

    '''

    def endPoint(self):

        at = self._pol.at(self._pol.count() - 1)

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

    '''

        @brief      return bouding rectangle of polyline

        @author     humkyung

        @date       2018.07.23

    '''

    def boundingRect(self):

        rect = QRectF()

        if self._path is not None:

            rect = self._path.boundingRect()

            rect = QRectF(rect.left() - 5, rect.top() - 5, rect.width() + 10, rect.height() + 10)

        else:

            minX = None

            minY = None

            maxX = None

            maxY = None

            for pt in self._vertices:

                if minX is None or pt[0] < minX:

                    minX = pt[0]

                if minY is None or pt[1] < minY:

                    minY = pt[1]

                if maxX is None or pt[0] > maxX:

                    maxX = pt[0]

                if maxY is None or pt[1] > maxY:

                    maxY = pt[1]

            if self._pt is not None:

                if minX is None or self._pt[0] < minX:

                    minX = self._pt[0]

                if minY is None or self._pt[1] < minY:

                    minY = self._pt[1]

                if maxX is None or self._pt[0] > maxX:

                    maxX = self._pt[0]

                if maxY is None or self._pt[1] > maxY: