HYTOS

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