HYTOS

# coding: utf-8

import sys

import os.path

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

    from PyQt5.QtWidgets import *

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Commands')

import DefaultCommand

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from SymbolSvgItem import SymbolSvgItem

__author__ = "Marcel Goldschen-Ohm <marcel.goldschen@gmail.com>"

__version__ = '0.9.0'

class QtImageViewer(QGraphicsView):

    """ PyQt image viewer widget for a QPixmap in a QGraphicsView scene with mouse zooming and panning.

    Displays a QImage or QPixmap (QImage is internally converted to a QPixmap).

    To display any other image format, you must first convert it to a QImage or QPixmap.

    Some useful image format conversion utilities:

        qimage2ndarray: NumPy ndarray <==> QImage    (https://github.com/hmeine/qimage2ndarray)

        ImageQt: PIL Image <==> QImage  (https://github.com/python-pillow/Pillow/blob/master/PIL/ImageQt.py)

    Mouse interaction:

        Left mouse button drag: Pan image.

        Right mouse button drag: Zoom box.

        Right mouse button doubleclick: Zoom to show entire image.

    """

    # Mouse button signals emit image scene (x, y) coordinates.

    # !!! For image (row, column) matrix indexing, row = y and column = x.

    leftMouseButtonPressed = pyqtSignal(float, float)

    rightMouseButtonPressed = pyqtSignal(float, float)

    leftMouseButtonMoved = pyqtSignal(float, float)

    rightMouseButtonMoved = pyqtSignal(float, float)

    leftMouseButtonReleased = pyqtSignal(float, float)

    rightMouseButtonReleased = pyqtSignal(float, float)

    leftMouseButtonDoubleClicked = pyqtSignal(float, float)

    rightMouseButtonDoubleClicked = pyqtSignal(float, float)

    #itemRemoved = pyqtSignal(QGraphicsItem)

    startPointChanged = pyqtSignal(float, float)

    '''

        @history    2018.06.27  Jeongwoo    Change zoom rule (Qt.KeepAspectRatioByExpanding → Qt.KeepAspectRatio)

    '''

    def __init__(self, mainWindow = None):

        from QtImageViewerScene import QtImageViewerScene

        QGraphicsView.__init__(self)

        self.mainWindow = mainWindow

        # Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.

        self.command = None

        self.scene = QtImageViewerScene(mainWindow)

        self.setScene(self.scene)

        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)

        self.scaleFactor = 1.0

        self.numScheduledScalings = 0

        self.isOriginalPointSelected = False

        # Store a local handle to the scene's current image pixmap.

        self._pixmapHandle = None

        # Image aspect ratio mode.

        # !!! ONLY applies to full image. Aspect ratio is always ignored when zooming.

        #   Qt.IgnoreAspectRatio: Scale image to fit viewport.

        #   Qt.KeepAspectRatio: Scale image to fit inside viewport, preserving aspect ratio.

        #   Qt.KeepAspectRatioByExpanding: Scale image to fill the viewport, preserving aspect ratio.

        self.aspectRatioMode = Qt.KeepAspectRatio

        # Scroll bar behaviour.

        #   Qt.ScrollBarAlwaysOff: Never shows a scroll bar.

        #   Qt.ScrollBarAlwaysOn: Always shows a scroll bar.

        #   Qt.ScrollBarAsNeeded: Shows a scroll bar only when zoomed.

        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        # Stack of QRectF zoom boxes in scene coordinates.

        self.zoomStack = []

        self.setRenderHint(QPainter.Antialiasing)

        self.setAcceptDrops(True)  # enable drop

        # Flags for enabling/disabling mouse interaction.

        self.canZoom = True

        self.canPan = True

        self.setMouseTracking(True)

        self.command = None

        self.guidesEnabled = False

        self._guidePen = QPen()

        self._guidePen.setColor(QColor(180, 180, 180))

        self._guidePen.setStyle(Qt.DashLine)

        self._guidePen.setWidthF(0.3)

        # set currentAttribute

        self.currentAttribute = ''

    '''

        @brief      Return Pixmap Handler

        @author     Jeongwoo

        @date       2018.06.11

    '''

    def getPixmapHandle(self):

        return self._pixmapHandle

    '''

        @brief      Use Default ImageViewer Command

        @author     Jeongwoo

        @date       18.04.10

        @history    .

    '''

    def useDefaultCommand(self):

        """ Use Default Command """

        if self.command is not None:

            self.command.reset()

        self.command = DefaultCommand.DefaultCommand(self)

    def hasImage(self):

        """ Returns whether or not the scene contains an image pixmap.

        """

        return self._pixmapHandle is not None

    def clearImage(self):

        """ Removes the current image pixmap from the scene if it exists.

        """

        if self.hasImage():

            self.scene.removeItem(self._pixmapHandle)

            self._pixmapHandle = None

    def pixmap(self):

        """ Returns the scene's current image pixmap as a QPixmap, or else None if no image exists.

        :rtype: QPixmap | None

        """

        if self.hasImage():

            return self._pixmapHandle.pixmap()

        return None

    def image(self):

        """ Returns the scene's current image pixmap as a QImage, or else None if no image exists.

        :rtype: QImage | None

        """

        if self.hasImage():

            return self._pixmapHandle.pixmap().toImage()

        return None

    def setImage(self, image):

        """ Set the scene's current image pixmap to the input QImage or QPixmap.

        Raises a RuntimeError if the input image has type other than QImage or QPixmap.

        :type image: QImage | QPixmap

        """

        try:

            if type(image) is QPixmap:

                pixmap = image

            elif type(image) is QImage:

                pixmap = QPixmap.fromImage(image)

            else:

                raise RuntimeError("ImageViewer.setImage: Argument must be a QImage or QPixmap.")

            self.clearImage()

            self.scene.clear()

            if self.hasImage():

                self._pixmapHandle.setPixmap(pixmap)

            else:

                self._pixmapHandle = self.scene.addPixmap(pixmap)

                self._pixmapHandle.setFlags(QGraphicsItem.ItemClipsChildrenToShape)

            self.setSceneRect(QRectF(pixmap.rect()))  # Set scene size to image size.

            self.updateViewer()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    '''

        @brief  open a image file selected by user

        @author 

        @date

    '''

    def loadImageFromFile(self, folder='', fileName=""):

        """ Load an image from file.

        Without any arguments, loadImageFromFile() will popup a file dialog to choose the image file.

        With a fileName argument, loadImageFromFile(fileName) will attempt to load the specified image file directly.

        """

        try:

            if len(fileName) == 0:

                options = QFileDialog.Options()

                options |= QFileDialog.DontUseNativeDialog

                if QT_VERSION_STR[0] == '4':

                    fileName = QFileDialog.getOpenFileName(self, "Open image file", os.getcwd() if folder == '' else folder, "Image files(*.png *.jpg)", options=options)

                elif QT_VERSION_STR[0] == '5':

                    fileName, dummy = QFileDialog.getOpenFileName(self, "Open image file", os.getcwd() if folder == '' else folder, "Image files(*.png *.jpg)", options=options)

            if len(fileName) and os.path.isfile(fileName):

                image = QImage(fileName, format = None)

                self.setImage(image)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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 fileName

    def zoom_rect(self, rect: QRectF) -> None:

        """zoom window within given rectangle"""

        self.fitInView(rect, Qt.KeepAspectRatio)

        if not self.zoomStack:

            self.zoomStack = []

        self.zoomStack.append(rect)

    def updateViewer(self, zoomNewRect=None):

        """Show current zoom (if showing entire image, apply current aspect ratio mode)."""

        if self.zoomStack:

            if zoomNewRect is None:

                self.fitInView(self.zoomStack[-1], Qt.KeepAspectRatio)  # Show zoomed rect (ignore aspect ratio).

            else:

                self.fitInView(zoomNewRect, Qt.KeepAspectRatio)

        else:

            self.zoomStack = []  # Clear the zoom stack (in case we got here because of an invalid zoom).

            self.fitInView(self.sceneRect(), self.aspectRatioMode)  # Show entire image (use current aspect ratio mode).

    def zoomImageInit(self):

        self.zoomStack = []

        self.updateViewer()

        self.setCursor(QCursor(Qt.ArrowCursor))

    '''

        @brief      Zoom in & out image

        @author     Jeongwoo

        @date       -

        @history    18.04.11    Jeongwoo    add parameter 'adjust' (@ref ResultTreeWidget.itemClickEvent(self, item, columnNo))

    '''

    def zoomImage(self, isZoomIn, event, adjust = 1):

        """Zoom in & out"""

        HALF_SIZE = 300

        clickPos = event.pos()

        left_top = self.mapToScene(clickPos.x() - HALF_SIZE//adjust, clickPos.y() - HALF_SIZE//adjust)

        right_bottom = self.mapToScene(clickPos.x() + HALF_SIZE//adjust, clickPos.y() + HALF_SIZE//adjust)

        if isZoomIn:

            zoomArea = QRectF(left_top, right_bottom)

            viewBBox = self.zoomStack[-1] if self.zoomStack else self.sceneRect()

            selectionBBox = zoomArea.intersected(viewBBox)

            self.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if selectionBBox.isValid() and (selectionBBox != viewBBox):

                self.zoomStack.append(selectionBBox)

                self.updateViewer()

        else:

            zoomNewRect = None

            self.scene.setSelectionArea(QPainterPath())  # Clear current selection area.

            if self.zoomStack:

                zoomNewRect = self.zoomStack.pop()

            self.updateViewer(zoomNewRect)

    """

    def resizeEvent(self, event):

        Maintain current zoom on resize.

        self.updateViewer()

    """

    '''

        @brief  mouse move event

    '''

    def mouseMoveEvent(self, event):

        try:

            scenePos = self.mapToScene(event.pos())

            if self.command is not None:

                self.command.execute(['mouseMoveEvent', event, scenePos])

                if self.command.name == "SelectAttribute":

                    QGraphicsView.mouseMoveEvent(self, event)

                if self.command.isTreated == True: return

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

        QGraphicsView.mouseMoveEvent(self, event)

    '''

        @brief      

        @author     

        @date       

        @history    block clear selection when right mouse button is clicked

    '''

    def mousePressEvent(self, event):

        try:

            if self.command is not None:

                scenePos = self.mapToScene(event.pos())

                self.command.execute(['mousePressEvent', event, scenePos])

                if self.command.isTreated == True: return

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

        if event.button() != Qt.RightButton:

            QGraphicsView.mousePressEvent(self, event)

    '''

        @brief      

        @author     

        @date       

    '''

    def mouseReleaseEvent(self, event):

        try:

            if self.command is not None:

                scenePos = self.mapToScene(event.pos())

                instance = self.command.execute(['mouseReleaseEvent', event, scenePos])

                if instance is not None:

                    self.scene.addItem(instance)

                if self.command is not None and self.command.isTreated == True: 

                    if self.command.name == 'Default' and self.command.isCopy:

                        return

                    self.command = DefaultCommand.DefaultCommand(self)

                    cursor = QCursor(Qt.ArrowCursor)

                    QApplication.instance().setOverrideCursor(cursor)

                    return

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

        QGraphicsView.mouseReleaseEvent(self, event)

    """

        @brief      Show entire image.

    """

    def mouseDoubleClickEvent(self, event):

        scenePos = self.mapToScene(event.pos())

        if self.command is not None:

            instance = self.command.execute(['mouseDoubleClickEvent', event, scenePos])

            if self.command.isTreated == True: return

        if event.button() == Qt.LeftButton:

            self.leftMouseButtonDoubleClicked.emit(scenePos.x(), scenePos.y())

        elif event.button() == Qt.RightButton:

            if self.canZoom:

                self.zoomStack = []  # Clear zoom stack.

                self.updateViewer()

            self.rightMouseButtonDoubleClicked.emit(scenePos.x(), scenePos.y())

        QGraphicsView.mouseDoubleClickEvent(self, event)

    '''

        @brief  key release event

        @author Jeongwoo

        @date   2018.??.??

    '''

    def keyReleaseEvent(self, event):

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

            pass

        QGraphicsView.keyReleaseEvent(self, event)

    '''

        @brief      mouse wheel event

        @autor      humkyung

        @date       

    '''

    def wheelEvent(self, event):

        if event.modifiers() == Qt.ControlModifier:

            if self.canZoom:

                numDegrees = event.angleDelta() / 8

                if numDegrees is not None:

                    if numDegrees.y() > 0:

                        self.zoomImage(True, event)

                    elif numDegrees.y() < 0:

                        self.zoomImage(False, event)

        else:

            super().wheelEvent(event)

    '''

        @brief      

    '''

    def drawForeground(self, painter, rect):

        if hasattr(self, 'coords') and self.guidesEnabled:

            painter.setClipRect(rect)

            painter.setPen(self._guidePen)

            painter.drawLine(round(self.coords.x()), rect.top(), round(self.coords.x()), rect.bottom())

            painter.drawLine(rect.left(), round(self.coords.y()), rect.right(), round(self.coords.y()))

        '''

        image = self.image()

        if image is not None:

            width = rect.width()

            height = rect.height()

            if self.crosshairPos is not None:

                pen = QPen()

                pen.setColor(QColor(180, 180, 180))

                pen.setStyle(Qt.DashLine)

                pen.setWidthF(0.3)

                painter.setClipRect(rect)

                painter.setPen(pen)

                painter.drawLine(self.crosshairPos.x(), 0, self.crosshairPos.x(), height)#Vertical

                painter.drawLine(0, self.crosshairPos.y(), width, self.crosshairPos.y())#Horizontal

            #else:

            #    painter.eraseRect(QRectF(0, 0, width, height))

        '''

    '''

        @brief      draw background

        @author     humkyung

        @date       2018.07.23

    '''        

    def drawBackground(self, painter, rect):

        from HydroCalculationCommand import HydroCalculationCommand

        QGraphicsView.drawBackground(self, painter, rect)

        painter.setPen(Qt.gray)

        painter.setBrush(Qt.gray)

        rect = self.sceneRect()

        rect.setLeft(rect.left() + 5)

        rect.setTop(rect.top() + 5)

        painter.fillRect(rect, Qt.gray)

        painter.setPen(Qt.white)

        painter.setBrush(Qt.white)

        rect.setLeft(rect.left() - 5)

        rect.setTop(rect.top() - 5)

        rect.setRight(rect.right() - 5)

        rect.setBottom(rect.bottom() - 5)

        if not HydroCalculationCommand.ERRORS:

            painter.fillRect(rect, QBrush(Qt.white))

        else:

            painter.fillRect(rect, QBrush(Qt.lightGray))

    '''

        @history    2018.06.11  Jeongwoo    Change method to manage guideline items

                    humkyung 2018.08.28 remove guide lines before drawing

    '''

    GUIDELINE_ITEMS = []

    def showGuideline(self, pos, isShow):

        image = self.image()

        width = image.width()

        height = image.height()

        pen = QPen()

        pen.setColor(QColor(180, 180, 180))

        pen.setStyle(Qt.DashLine)

        pen.setWidthF(0.5)

        if isShow:

            items = self.scene.items()

            for item in self.GUIDELINE_ITEMS:

                if item in items:

                    self.scene.removeItem(item)

            self.GUIDELINE_ITEMS.clear()

            if pos is not None:

                verticalLine = self.scene.addLine(pos.x(), 0, pos.x(), height, pen)

                horizontalLine = self.scene.addLine(0, pos.y(), width, pos.y(), pen)

            else:

                verticalLine = self.scene.addLine(round(width*0.5), 0, round(width*0.5), height, pen)

                horizontalLine = self.scene.addLine(0, round(height*0.5), width, round(height*0.5), pen)

            self.GUIDELINE_ITEMS.append(verticalLine)

            self.GUIDELINE_ITEMS.append(horizontalLine)

        else:

            items = self.scene.items()

            for item in self.GUIDELINE_ITEMS:

                if item in items:

                    self.scene.removeItem(item)

            self.GUIDELINE_ITEMS.clear()

    '''

        @brief  drag enter event

        @author humkyung

        @date   2018.04.17

    '''

    def dragEnterEvent(self, event):

        event.acceptProposedAction()

    '''

        @brief      drag move event

        @author     humkyung

        @date       2018.04.17

        @history    humkyung 2018.08.21 highlight item under mouse

    '''

    def dragMoveEvent(self, event):

        scenePos = self.mapToScene(event.pos())

        items = [item for item in self.scene.items(scenePos) if type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem]

        if len(items) > 0:

            if not hasattr(self, '_underItem') or self._underItem is not items[0]:

                if hasattr(self, '_underItem') and self._underItem is not None:

                    if hasattr(self._underItem, 'highlight'):

                        self._underItem.highlight(False)

                self._underItem = items[0]

                if hasattr(self._underItem, 'highlight'):

                    self._underItem.highlight(True)

        #elif hasattr(self, '_underItem') and self._underItem is not None:

        #    self._underItem.hoverLeaveEvent(event)

        #    self._underItem = None

        event.acceptProposedAction()

    def dropEvent(self, event):

        """create a symbol"""

        try:

            from AppDocData import AppDocData

            import symbol

            scenePos = self.mapToScene(event.pos())

            uid = event.mimeData().text()

            svg = self.scene.createSymbolObject(uid, scale=None, angle=None)

            if svg:

                self.scene.place_symbol(svg, scenePos)

            event.acceptProposedAction()

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) 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)

    '''

        @brief  find item by uid (SymbolSvgItem 기반, QEngineeringConnectorItem 제외, QEngineeringLineItem 포함)

        @author kyouho

        @date   2018.07.31

    '''

    def findItemByUid(self, uid):

        items = [item for item in self.scene.items() if hasattr(item, 'uid') and str(item.uid) == str(uid)]

        return items[0] if items else None

    def save_as_image(self, file_path):

        """ save scene as given file """

        try:

            rect = self.scene.itemsBoundingRect()

            default = QSize(rect.width()*1, rect.height()*1)

            image = QImage(default, QImage.Format_ARGB32_Premultiplied)

            painter = QPainter(image)

            # render the scene

            self.scene.render(painter, QRectF(image.rect()), rect)

            painter.end()

            # save the image to a given file

            image.save(file_path)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

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

    def save_as_svg(self, file_path):

        """ save scene as given file """

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

        def prettify(elem):

            """Return a pretty-printed XML string for the Element."""

            from xml.etree import ElementTree

            from xml.dom import minidom

            try:

                rough_string = ElementTree.tostring(elem, 'utf-8')

                reparsed = minidom.parseString(rough_string)

                return reparsed.toprettyxml(indent="  ")

            except Exception as ex:

                from AppDocData import MessageType

                message = f'error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:' \

                          f'{sys.exc_info()[-1].tb_lineno}'

                self.display_message.emit(MessageType.Error, message)

        try:

            rect = self.scene.itemsBoundingRect()

            svg = Element('svg')

            svg.attrib['width'] = f"{rect.width()}"

            svg.attrib['height'] = f"{rect.height()}"

            svg.attrib['viewBox'] = f"{rect.left()} {rect.top()} {rect.width()} {rect.height()}"

            svg.attrib['xmlns'] = 'http://www.w3.org/2000/svg'

            svg.attrib['xmlns:xlink'] = "http://www.w3.org/1999/xlink"

            svg.attrib['xmlns:inkscape'] = "http://www.inkscape.org/namespaces/inkscape"

            svg.attrib['version'] = "1.1"

            svg.attrib['baseProfile'] = "tiny"

            for item in self.scene.items():

                if hasattr(item, 'to_svg'):

                    node = item.to_svg(None)

                    if node:

                        svg.extend(node)

            with open(file_path, 'w', encoding='utf-8') as output_file:

                output_file.write(prettify(svg))

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

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

if __name__ == '__main__':

    import sys

    try:

        from PyQt5.QtWidgets import QApplication

    except ImportError:

        try:

            from PyQt4.QtGui import QApplication

        except ImportError:

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

    def handleLeftClick(x, y):

        row = int(y)

        column = int(x)

    # Create the application.

    app = QApplication(sys.argv)

    # Create image viewer and load an image file to display.

    viewer = QtImageViewer(None)

    viewer.loadImageFromFile()  # Pops up file dialog.

    # Handle left mouse clicks with custom slot.

    viewer.leftMouseButtonPressed.connect(handleLeftClick)

    # Show viewer and run application.

    viewer.show()

    sys.exit(app.exec_())