HYTOS

# coding: utf-8

""" This is stream line item module """

import sys

import os.path

import copy

import numpy as np

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

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 EngineeringAbstractItem import QEngineeringAbstractItem

class QEngineeringStreamlineItem(QGraphicsPathItem, QEngineeringAbstractItem):

    """ This is EngineeringStreamlineItem Class """

    ARROW_SIZE = 10

    ZVALUE = 100

    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

        from EngineeringStreamNoTextItem import QEngineeringStreamNoTextItem

        try:

            QGraphicsPathItem.__init__(self, parent)

            QEngineeringAbstractItem.__init__(self)

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

            self.setAcceptHoverEvents(True)

            self.setAcceptTouchEvents(True)

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

            self.parent = parent

            self._vertices = []

            self.isCreated = False

            self._pt = None

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

            self._stream_no = QEngineeringStreamNoTextItem('<0>', self)

            self.transfer = Transfer()

            self.transfer.onRemoved.connect(self.on_item_removed)

            self.setZValue(QEngineeringStreamlineItem.ZVALUE)

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

    def build_connectors(self, connected, pointsUids=None):

        """ build connectors for stream line

            connected is target connector

        """

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringConnectorItem import QEngineeringConnectorItem 

        targets = []

        index = 0

        for vertex in [self._vertices[0],self._vertices[-1]]:          

            if pointsUids:

                connector = QEngineeringConnectorItem(pointsUids[index], parent=self, index=index+1)

            else: 

                connector = QEngineeringConnectorItem(uid=None, parent=self, index=index+1)

            connector.setPos(vertex)

            connector.setParentItem(self)

            connector.connectPoint = vertex

            connector.sceneConnectPoint = vertex

            # add connector move ables

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

            connector.setAcceptTouchEvents(True)

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

            connector.setZValue(self.zValue() + 1)

            self.connectors.append(connector)

            if len(connected) > index:

                connectedItemUid = connected[index]

                if connectedItemUid:

                    connector.connect(connectedItemUid)

                    target = QEngineeringConnectorItem.find_connector(connectedItemUid)

                    if target:

                        target.connect(connector)

                        targets.append(target)

            index = index + 1

        """ connect symbol's on_pos_changed signal """

        for symbol in [conn.parentItem() for conn in targets if type(conn.parentItem()) is SymbolSvgItem]:

            symbol.transfer.on_pos_changed.connect(self.on_symbol_pos_changed)

        self.update_arrow()

    def update_arrow(self):

        """ update flow arrow """

        import math

        from EngineeringArrowItem import QEngineeringArrowItem

        if len(self._vertices) < 2: return

        start = self._vertices[-2]

        end = self._vertices[-1]

        dx = end[0] - start[0]

        dy = end[1] - start[1]

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

        if length == 0: return

        _dir = [(end[0] - start[0])/length, (end[1] - start[1])/length]

        perpendicular = (-_dir[1], _dir[0])

        polygon = QPolygonF()

        polygon.append(QPointF(end[0] - _dir[0]*QEngineeringStreamlineItem.ARROW_SIZE + perpendicular[0]*QEngineeringStreamlineItem.ARROW_SIZE*0.25, 

                            end[1] - _dir[1]*QEngineeringStreamlineItem.ARROW_SIZE + perpendicular[1]*QEngineeringStreamlineItem.ARROW_SIZE*0.25))

        polygon.append(QPointF(end[0] - _dir[0]*QEngineeringStreamlineItem.ARROW_SIZE - perpendicular[0]*QEngineeringStreamlineItem.ARROW_SIZE*0.25, 

                            end[1] - _dir[1]*QEngineeringStreamlineItem.ARROW_SIZE - perpendicular[1]*QEngineeringStreamlineItem.ARROW_SIZE*0.25))

        polygon.append(QPointF(end[0], end[1]))

        polygon.append(polygon[0])  # close polygon

        if not hasattr(self, '_arrow'):

            self._arrow = QEngineeringArrowItem(polygon, self)

        else:

            self._arrow.setPolygon(polygon)

        self._arrow.setBrush(Qt.blue)

        self._arrow.update()

    '''

        @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 = QEngineeringStreamlineItem()

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

        clone.isCreated = self.isCreated

        return clone

    def init(self):

        self._vertices = []

        self._pt = None

        self.isCreated = False

    def buildItem(self):

        self.__buildItem()        

    '''

        @build  build path

        @author humkyung

        @date   2018.04.23

    '''

    def __buildItem(self):

        import math

        path = QPainterPath()

        path.moveTo(self._vertices[0][0], self._vertices[0][1])

        max_length = 0

        max_length_line = [None, None]

        for i in range(1, len(self._vertices)):

            path.lineTo(self._vertices[i][0], self._vertices[i][1])

            dx = self._vertices[i][0] - self._vertices[i-1][0]

            dy = self._vertices[i][1] - self._vertices[i-1][1]

            if dx*dx + dy*dy > max_length:

                max_length = dx*dx + dy*dy

                max_length_line[0] = self._vertices[i-1]

                max_length_line[1] = self._vertices[i]

        self.setPath(path)

        self.isCreated = True

        if max_length_line[0] is not None and max_length_line[1] is not None:

            x = (max_length_line[0][0] + max_length_line[1][0] - self._stream_no.textWidth())*0.5

            y = (max_length_line[0][1] + max_length_line[1][1])*0.5

            self._stream_no.setPos(QPointF(x, y))

            dx = max_length_line[0][0] - max_length_line[1][0]

            dy = max_length_line[0][1] - max_length_line[1][1]

            self._stream_no.setRotation(90) if abs(dy) > abs(dx) else self._stream_no.setRotation(0)

    '''

        @brief      return bouding rectangle of polyline

        @author     humkyung

        @date       2018.07.23

    '''

    def boundingRect(self):

        rect = QRectF()

        if self.isCreated:

            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:

                    maxY = self._pt[1]

            if minX is not None and minY is not None and maxX is not None and maxY is not None:

                rect = QRectF(minX - 5, minY - 5, maxX - minX + 10, maxY - minY + 10)

        return rect

    '''

        @brief      

        @author     humkyung

        @date       2018.07.26

    '''

    def onMouseMoved(self, event, scenePos):

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringConnectorItem import QEngineeringConnectorItem

        # get connection point near by mouse point

        pt = (scenePos.x(), scenePos.y())

        item = self.scene().itemAt(scenePos, 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

        del self._vertices[1:]

        dx = pt[0] - self._vertices[0][0]

        dy = pt[1] - self._vertices[0][1]

        self._vertices.append((self._vertices[0][0] + dx*0.5, self._vertices[0][1]))

        self._vertices.append((self._vertices[-1][0], self._vertices[-1][1] + dy))

        self._vertices.append(pt)

        self.__buildItem()

        self.update()

    def hoverEnterEvent(self, event):

        """ hilight item and it's children """

        self.highlight(True)

    def hoverLeaveEvent(self, event):

        """ unhighlight item """

        self.highlight(False)

    def highlight(self, flag):

        self.hover = flag 

        self.setZValue(QEngineeringAbstractItem.HOVER_ZVALUE) if flag else self.setZValue(QEngineeringStreamlineItem.ZVALUE)

        self.update()

    '''

        @brief      override paint method

        @history    humkyung 2018.08.30 draw flowmark only for Primary or Secondary

    '''

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

        if self.isSelected():

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

            focuspen = QPen(Qt.DotLine)

            focuspen.setColor(hilightColor)

            focuspen.setWidthF(10)

            brush = QBrush(hilightColor, Qt.Dense7Pattern)

            painter.setBrush(brush)

            painter.setPen(focuspen)

        else:

            color = self.getColor()

            self.setColor(color)

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

    def on_item_removed(self, item): 

        """ remove item from scene and then delete it """

        if item is self:

            for conn in item.connectors:

                if conn.connectedItem is not None: conn.connectedItem.connect(None)                

            self.scene().removeItem(item)

            del item

    '''

        @brief      Return real item position

        @authro     Jeongwoo

        @date       2018.05.29

    '''

    def boundingRectOnScene(self):

        rect = self.boundingRect()

        sp = self.startPoint()

        rect.moveTo(sp[0], sp[1])

        return rect

    '''

        @brief      Set Color. Override QEngineeringAbstractItem's

        @author     Jeongwoo

        @date       2018.05.11

        @history    2018.05.11  Jeongwoo    Add self.setPen() Method

        @history    humkyung 2018.05.13 call setPen method to apply changed color

    '''

    def setColor(self, color):

        c = QColor()

        c.setNamedColor(color)

        _pen = self.pen()

        _pen.setColor(c)

        self.setPen(_pen)

        self.update()

    def on_symbol_pos_changed(self, symbol):

        """ rebuild stream line because symbol position is changed """

        if self.connectors[0].connectedItem is not None : self.connectors[0].setPos(self.connectors[0].connectedItem.center())

        if self.connectors[-1].connectedItem is not None : self.connectors[-1].setPos(self.connectors[-1].connectedItem.center())

        self.on_connector_pos_changed(None)

    def on_connector_pos_changed(self, connector):

        """ rebuild stream line """

        self._vertices = []

        self._vertices.append(self.connectors[0].center())

        dx = self.connectors[-1].center()[0] - self._vertices[0][0]

        dy = self.connectors[-1].center()[1] - self._vertices[0][1]

        self._vertices.append((self._vertices[0][0] + dx*0.5, self._vertices[0][1]))

        self._vertices.append((self._vertices[-1][0], self._vertices[-1][1] + dy))

        self._vertices.append(self.connectors[-1].center())

        self.__buildItem()

        self.update_arrow()

        self.update()

    def mouseDoubleClickEvent(self, event):

        from AppDocData import AppDocData

        from MainWindow import MainWindow

        from PhaseTypeDialog import QPhaseTypeDialog

        from HMBTable import HMBTable

        dialog = QPhaseTypeDialog(None)

        selectedPhaseType = dialog.showDialog()

        if selectedPhaseType:

            drawing = AppDocData.instance().activeDrawing

            hmbs = drawing.hmbTable._hmbs

            if hmbs is not None:

                for hmb in hmbs:

                    hmb.phase_type = selectedPhaseType

    def keyPressEvent(self, event):

        from App import App

        if not self.isSelected(): return

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

            self.deleteStreamlineItemFromScene()

            self.deleteHMBDataByUID()

            App.mainWnd().load_HMB()

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

            self.mouseDoubleClickEvent(event)    

    def deleteHMBDataByUID(self):

        from AppDocData import AppDocData

        deleteUid = str(self.uid)

        appDocData = AppDocData.instance()

        activeDrawing = appDocData.activeDrawing

        if activeDrawing:

            hmbs = activeDrawing.hmbTable._hmbs

            if hmbs is not None:     

                for hmb in hmbs:

                    if str(hmb.components_uid) == str(deleteUid):

                        hmb.isDeleted = True

                        break

    def deleteStreamlineItemFromScene(self):

        """ remove self from scene """

        try:

            for conn in self.connectors:

                if conn.connectedItem is not None:

                    conn.connectedItem.connect(None)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

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

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

        self.transfer.onRemoved.emit(self)

    def toSql(self):

        """ convert valve data to sql query """

        import uuid

        from AppDocData import AppDocData

        res = []

        appDocData = AppDocData.instance()

        symbolInfo = appDocData.getSymbolByQuery('name', 'Stream Line')

        dbUid = symbolInfo.uid

        uid = self.uid

        cols = ['UID', 'Drawings_UID', 'Symbols_UID']

        values = ['?','?','?']

        param = [str(uid), str(appDocData.activeDrawing.UID), str(dbUid)]

        sql = 'insert or replace into Components({}) values({})'.format(','.join(cols), ','.join(values))

        res.append((sql, tuple(param)))

        # save vertices to database

        index = 1

        for vertex in self._vertices:                                    

            if index == 1 and self.connectors[0].connectedItem is not None:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y', 'ConnectedItem_UID']

                values = ['?', '?', '?', '?', '?', '?']

                param = [str(uuid.uuid4()), str(uid), index, vertex[0], vertex[1], str(self.connectors[0].connectedItem.uid)]

            elif index == 4 and self.connectors[1].connectedItem is not None:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y', 'ConnectedItem_UID']

                values = ['?', '?', '?', '?', '?', '?']

                param = [str(uuid.uuid4()), str(uid), index, vertex[0], vertex[1], str(self.connectors[1].connectedItem.uid)]

            else:

                cols = ['UID', 'Components_UID', '[Index]', 'X', 'Y']

                values = ['?', '?', '?', '?', '?']

                param = [str(uuid.uuid4()), str(uid), index, vertex[0], vertex[1]]

            sql = 'insert or replace into Points({}) values({})'.format(','.join(cols), ','.join(values))

            res.append((sql, tuple(param)))

            index += 1

        # up to here

        return res

    @staticmethod 

    def fromDatabase(componentInfos):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        item = None

        try:

            uid = componentInfos[0][0]              #uid@Components

            item = QEngineeringStreamlineItem(uid)

            connectorItems = []

            pointsUids = []

            for componentInfo in componentInfos:     

                pointsUid = componentInfo[11]           # uid@Points           

                index = componentInfo[12]               # Index@Points

                x = componentInfo[13]                   # X@Points

                y = componentInfo[14]                   # Y@Points

                ConnectedItem_UID = componentInfo[15]   # ConnectedItem_UID@Points

                pointsUids.append(pointsUid)

                item._vertices.append((x, y))

                if index == 1 or index == 4:

                    connectorItems.append(ConnectedItem_UID)                

            item.setVisible(False)

            item.__buildItem()

            item.build_connectors(connectorItems, pointsUids)

            item.update()

        except Exception as ex:

            from App import App 

            from AppDocData import MessageType

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

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

        return item

'''

    @brief      The class transfer pyqtSignal Event. Cause Subclass of QGraphicsRectItem can't use pyqtSignal

    @author     Jeongwoo

    @date       2018.06.18

'''

class Transfer(QObject):

    onRemoved = pyqtSignal(QGraphicsItem)

    def __init__(self, parent = None):

        QObject.__init__(self, parent)