HYTOS

# coding: utf-8

""" This is place stream line module """

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 PlaceStreamlineCommand(AbstractCommand.AbstractCommand):

    """ This is place line class """

    onSuccess = pyqtSignal()

    onRejected = pyqtSignal(AbstractCommand.AbstractCommand)

    def __init__(self, imageViewer):

        super(PlaceStreamlineCommand, self).__init__(imageViewer)

        self.name = 'PlaceLine' 

        self.imageViewer.setCursor(QCursor(Qt.CrossCursor))

        self._streamline = None

    '''

        @brief      reset command status

        @author     humkyung

        @date       2018.07.23

    '''

    def reset(self):

        self._streamline = None

    '''

        @brief      place a line

        @author     humkyung

        @date       2018.07.23

    '''

    def execute(self, param):

        import shapely

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringStreamlineItem import QEngineeringStreamlineItem

        self.isTreated = False

        event = param[1]

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

            if self._streamline is None:

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

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

                    self._streamline = QEngineeringStreamlineItem()

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

                    self.imageViewer.scene.addItem(self._streamline)

                    self.imageViewer.scene.setFocusItem(self._streamline)

            else:

                try:

                    QGraphicsView.mouseReleaseEvent(self.imageViewer, event)

                    self._streamline.update()

                    self.onSuccess.emit()

                finally:

                    pass

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

            self.onRejected.emit(self)

        elif 'mouseMoveEvent' == param[0] and self._streamline is not None:

            self._streamline.onMouseMoved(event, param[2])

        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 PlaceStreamlineCommand

        """

        """

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

# coding: utf-8

"""

This is Polyline item module

"""

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, QTransform

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

class QEngineeringStreamlineItem(QGraphicsPathItem, QEngineeringAbstractItem):

    """ This is EngineeringPolylineItem Class """

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

    @property

    def drawing_mode(self):

        return self._drawing_mode

    @drawing_mode.setter

    def drawing_mode(self, value):

        self._drawing_mode = value

    '''

        @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

    '''

        @build  build path

        @author humkyung

        @date   2018.04.23

    '''

    def buildItem(self):

        path = QPainterPath()

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

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

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

        self.setPath(path)

        self.isCreated = True

    '''

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

    '''

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

'''

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