HYTOS

# coding: utf-8

import os.path

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath, QPainter, QCursor, QPen, QBrush, QColor

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import *

        from PyQt4.QtGui import *

    except ImportError:

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

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

    def __init__(self):

        QGraphicsView.__init__(self)

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

        self.command = None

        self.scene = QGraphicsScene()

        self.setScene(self.scene)

        self.scene.setBackgroundBrush(Qt.gray)

        self.crosshairPos = None

        self.isPressCtrl = False

        self.scaleFactor = 1.0

        self.numScheduledScalings = 0

        self.isOriginalPointSelected = False

        #self.currentMenuTool = self.MENU_HAND_TOOL

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

        # Flags for enabling/disabling mouse interaction.

        self.canZoom = True

        self.canPan = True

        self.setMouseTracking(True)

        self.command = None

    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

        """

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

        if self.hasImage():

            self._pixmapHandle.setPixmap(pixmap)

        else:

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

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

        self.updateViewer()

    def loadImageFromFile(self, 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.

        """

        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(), "Image files(*.png *.jpg)", options=options)

            elif QT_VERSION_STR[0] == '5':

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

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

            image = QImage(fileName)

            self.setImage(image)

        return fileName

    def updateViewer(self):

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

        """

        if not self.hasImage():

            return

        if len(self.zoomStack) and self.sceneRect().contains(self.zoomStack[-1]):

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

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

        if self.hasImage():

            self.zoomStack = []

            self.updateViewer()

            self.setCursor(QCursor(Qt.ArrowCursor))

    def zoomImage(self, isZoomIn, event):

        """ Zoom in & out

        """

        clickPos = event.pos()

        scenePos1 = self.mapToScene(clickPos.x() - 300, clickPos.y() - 300)

        scenePos2 = self.mapToScene(clickPos.x() + 300, clickPos.y() + 300)

        if isZoomIn:

            print("zoom in")

            zoomArea = QRectF(QPointF(scenePos1.x(), scenePos1.y()), QPointF(scenePos2.x(), scenePos2.y()))

            viewBBox = self.zoomStack[-1] if len(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:

            print("zoom out")

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

            if len(self.zoomStack):

                self.zoomStack.pop()

            self.updateViewer()

    def resizeEvent(self, event):

        """ Maintain current zoom on resize.

        """

        self.updateViewer()

    #'''

    #    @brief draw something event

    #'''

    #def paintEvent(self, event):

    #    if self.command is not None:

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

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

    #        if self.command.isTreated == True: return

    '''

        @brief  mouse move event

    '''

    def mouseMoveEvent(self, event):

        if self.command is not None:

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

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

            if self.command.isTreated == True: return

        QGraphicsView.mouseMoveEvent(self, event)

    def mousePressEvent(self, event):

        """ Start mouse pan or zoom mode.

        """

        if self.command is not None:

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

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

            if self.command.isTreated == True: return

        QGraphicsView.mousePressEvent(self, event)

    def mouseReleaseEvent(self, event):

        """ Stop mouse pan or zoom mode (apply zoom if valid).

        """

        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.isTreated == True: return

        QGraphicsView.mouseReleaseEvent(self, event)

    def mouseDoubleClickEvent(self, event):

        """ Show entire image.

        """

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

        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)

    def keyPressEvent(self, event):

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

            self.isPressCtrl = True

            print("Pressed Ctrl")

    def keyReleaseEvent(self, event):

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

            self.isPressCtrl = False

            print("Released Ctrl")

    def wheelEvent(self, event):

        if self.isPressCtrl == True:

            print("Pressed Ctrl and Mouse Wheel")

            if self.canZoom and self.hasImage():

                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)

                #print("Zoomable")

                #numDegrees = event.angleDelta().y() // 8

                #numSteps = numDegrees // 15

                #self.numScheduledScalings = self.numScheduledScalings + numSteps

                #if self.numScheduledScalings * numSteps < 0:

                #    self.numScheduledScalings = numSteps

                #self.scaleFactor = 1.0 + (self.numScheduledScalings / 300.0)

                #print("scaleFactor : " + str(self.scaleFactor))

                #self.scale(self.scaleFactor, self.scaleFactor)

        else:

            super().wheelEvent(event)

    def drawForeground(self, painter, rect):

        image = self.image()

        if image is not None:

            width = image.width()

            height = image.height()

            if self.crosshairPos is not None:

                pen = QPen()

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

                pen.setStyle(Qt.DashLine)

                pen.setWidthF(0.3)

                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  override paint event

    '''

    def paintEvent(self, event):

        try:

            super(QtImageViewer, self).paintEvent(event)

            #if (self.command is not None) and ('CreateCommand' == self.command.__class__.__name__):

            #    self.command.template.paint(QPainter(self))

        except Exception as ex:

            print('Error occurs', ex)

    GUIDELINE_ITEMS = []

    def showGuideline(self, 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:

            verticalLine = self.scene.addLine(width/2, 0, width/2, height, pen)

            horizontalLine = self.scene.addLine(0, height/2, width, height/2, pen)

            self.GUIDELINE_ITEMS.append(verticalLine)

            self.GUIDELINE_ITEMS.append(horizontalLine)

            self.scene.addItem(verticalLine)

            self.scene.addItem(horizontalLine)

        else:

            for item in self.GUIDELINE_ITEMS:

                self.scene.removeItem(item)

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

    print('Using Qt ' + QT_VERSION_STR)

    def handleLeftClick(x, y):

        row = int(y)

        column = int(x)

        print("Clicked on image pixel (row="+str(row)+", column="+str(column)+")")

    # Create the application.

    app = QApplication(sys.argv)

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

    viewer = QtImageViewer()

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