HYTOS

# coding: utf-8

import os.path

import copy

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, 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 QGraphicsPolylineItem import QGraphicsPolylineItem

from QGraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

import shapely

class QEngineeringLineItem(QGraphicsPolylineItem):

    removed = pyqtSignal(QGraphicsPathItem)

    '''

        @history    2018.05.11  Jeongwoo    Make Comments self.setPen()

                    2018.05.15  Jeongwoo    Change method to call parent's __init__

    '''

    def __init__(self, parent=None):

        #super(QEngineeringLineItem, self).__init__()

        QGraphicsPolylineItem.__init__(self, parent)

        self.conns = [None, None]

        self._owner = None

        #self.setPen(QPen(Qt.blue, 5, Qt.SolidLine))

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

        self.setAcceptHoverEvents(True)

        self.setAcceptTouchEvents(True)

    '''

        @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  construct a ProcessLineItem

        @author humkyung

    '''

    def process(self, param):

        from SymbolSvgItem import SymbolSvgItem

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

            self._vertices.append(self._pt)

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

            # get connection point near by mouse point

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

            item = self.scene().itemAt(pt[0], pt[1], QTransform())

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

                connPt = item.getConnectionPointCloseTo(pt, 5)

                if connPt is not None: pt = connPt

            # up to here

            if len(self._vertices) > 0:

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

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

                if dx < dy:

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

                else:

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

            else:

                self._pt = pt

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

            self.isCreated = True

    '''

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

        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*20, startPt[1] - dy*20), (endPt[0] + dx*20, endPt[1] + dy*20)]

        pt = self.intersection(extendedLine)

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

    '''

        @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  add flow arrow

        @author humkyung

        @date   2018.05.08

        @history    2018.05.24  Jeongwoo    Modifying Draw Flow Arrow

    '''

    def addFlowArrow(self):

        from QEngineeringFlowArrowItem import QEngineeringFlowArrowItem

        from AppDocData import AppDocData

        import numpy as np

        import cv2

        import math

        import sys

        try:

            rect = self.boundingRect()

            adjustRect = None

            adjustValue = 10

            if self.isVertical():

                adjustRect = rect.adjusted(-adjustValue, 0, adjustValue, 0)

            else:

                adjustRect = rect.adjusted(0, -adjustValue, 0, adjustValue)

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

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

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

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

        #    ####### HoughLinesP

            if lines is not None:

                for line in lines:

                    for x1, y1, x2, y2 in line:

                        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 

                        cv2.line(img,(x1,y1),(x2,y2),(0,0,255),2)

            cv2.imshow('img', img)

            cv2.waitKey(0)

            cv2.destroyAllWindows()

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

        startPt = self.startPoint()

        endPt = self.endPoint()

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

        length = self.length()

        dx = (endPt[0] - startPt[0]) / length

        dy = (endPt[1] - startPt[1]) / length

        arrow = QEngineeringFlowArrowItem(center, (dx,dy))

        arrow.buildItem()

        self.scene().addItem(arrow)

    '''

        @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.setPen(QPen(Qt.blue, 5, Qt.SolidLine))

                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.setPen(QPen(Qt.blue, 5, Qt.SolidLine))

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

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

        @author humkyung

        @date   2018.04.23

    '''

    def toXml(self):

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

        try:

            node = Element('LINE')

            uidNode = Element('UID')

            uidNode.text = str(self.uid)

            startPt = self.startPoint()

            endPt = self.endPoint()

            startNode = Element('STARTPOINT')

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

            endNode = Element('ENDPOINT')

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

            node.append(uidNode)

            node.append(startNode)

            node.append(endNode)

        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