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 EngineeringLineItem import QEngineeringLineItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from TrainingEditorDialog import QTrainingEditorDialog

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

        QGraphicsView.__init__(self)

        self.mainWindow = mainWindow

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

        self.command = None

        self.scene = QGraphicsScene(self)

        self.setScene(self.scene)

        self.scene.setBackgroundBrush(Qt.gray)

        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

        """

        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:

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

    '''

        @brief  open a image file selected by user

        @author 

        @date

    '''

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

        import cv2

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

                cvImg = cv2.cvtColor(cv2.imread(fileName), cv2.COLOR_BGR2GRAY)

                #blur = cv2.GaussianBlur(cvImg, (5,5),0)

                cvImg = cv2.threshold(cvImg, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1]

                bytesPerLine = cvImg.shape[1]

                image = QImage(cvImg.data, cvImg.shape[1], cvImg.shape[0], bytesPerLine, QImage.Format_Indexed8)

                self.setImage(image)

        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 fileName

    '''

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

    '''

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

    '''

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

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

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

        if isZoomIn:

            zoomArea = QRectF(QPointF(scenePos1.x() if scenePos1.x() > 0 else 0, scenePos1.y() if scenePos1.y() > 0 else 0), QPointF(scenePos2.x(), scenePos2.y()))

            #self.fitInView(zoomArea, Qt.KeepAspectRatioByExpanding)

            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.width() > HALF_SIZE*2 and selectionBBox.height() > HALF_SIZE*2:

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

                    self.zoomStack.append(selectionBBox)

                    self.updateViewer()

        else:

            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  mouse move event

    '''

    def mouseMoveEvent(self, event):

        try:

            if self.command is not None:

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

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

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

                    QGraphicsView.mouseMoveEvent(self, event)

                    #attrType = self.command._type

                    #item = self.scene.itemAt(scenePos, QTransform())

                    #if item is not None and attrType == 'Text Item' and type(item) is QEngineeringTextItem:

                    #    QGraphicsView.mouseMoveEvent(self, event)

                    #elif item is not None and attrType == 'Symbol Item' and issubclass(type(item), SymbolSvgItem):

                    #    QGraphicsView.mouseMoveEvent(self, event)

                    #elif item is not None and attrType == 'Line Item' and type(item) is QEngineeringLineItem:

                    #    QGraphicsView.mouseMoveEvent(self, event)

                if self.command.isTreated == True: return

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

        if self.guidesEnabled:

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

            self.scene.invalidate()

        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:

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

        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:

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

        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 press event

        @author     Jeongwoo

        @date       2018.??.??

        @history    send escape key event to command

    '''

    def keyPressEvent(self, event):

        try:

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

                for item in self.scene.selectedItems():

                    item.transfer.onRemoved.emit(item)

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

                if self.command is not None:

                    self.command.execute(['keyPressEvent', event, []])

                    if self.command.isTreated: return

            else:

                if self.command is not None:

                    self.command.execute(['keyPressEvent', event, []])

                    if self.command.isTreated: return

            if type(self.mainWindow) is QTrainingEditorDialog:

                self.mainWindow.keyPressEvent(event)

            QGraphicsView.keyPressEvent(self, event)

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

    '''

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

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

        QGraphicsView.drawBackground(self, painter, rect) 

    '''

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

        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:

                    self._underItem.hoverLeaveEvent(event)

                self._underItem = items[0]

                self._underItem.hoverEnterEvent(event)

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

            self._underItem.hoverLeaveEvent(event)

            self._underItem = None

        event.acceptProposedAction()

    '''

        @brief      drop event

        @author     humkyung

        @date       2018.04.17

        @history    2018.06.08  Jeongwoo    Add Paramter on SymbolSvgItem.buildItem()

                    humkyung 2018.08.21 call hoverLeaveEvent if item exists under mouse

    '''

    def dropEvent(self, event):

        from AppDocData import AppDocData

        import symbol

        if len(self.scene.items()) is 0:

            return

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

            self._underItem.hoverLeaveEvent(event)

            self._underItem = None

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

        svgFileName = event.mimeData().text()

        svg = self.createSymbolObject(svgFileName)

        self.matchSymbolToLine(svg, scenePos)

        if type(svg) is QEngineeringSpecBreakItem:

            self.command.specBreak_startPoint = [scenePos.x(), scenePos.y()]

            self.command.isCopy = True

            self.command.isSpecBreak = True

            self.command.symbol = svg

            while 0 != svg.angle:

                svg.rotateSymbol()

        event.acceptProposedAction()

    '''

        @brief  drop create Symbol

        @author kyouho

        @date   2018.07.27

    '''

    def createSymbolObject(self, svgFileName):

        from AppDocData import AppDocData

        import symbol

        symbol = AppDocData.instance().getSymbolByQuery('name', svgFileName)

        svgFilePath = os.path.join(AppDocData.instance().getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName+'.svg')

        svg = SymbolSvgItem.createItem(symbol.getType(), svgFilePath)

        connPts = None

        strConnPts = symbol.getConnectionPoint()

        if strConnPts is not None:

            connPts = [(float(x.split(',')[0]), float(x.split(',')[1])) if len(x.split(',')) == 2 else (x.split(',')[0], float(x.split(',')[1]), float(x.split(',')[2])) \

            for x in strConnPts.split('/')]

        svg.buildItem(svgFileName, symbol.getType(), 0, None, None, None, connPts, symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

        return svg

    '''

        @brief      match symbol to line

        @author     kyouho

        @date       2018.07.27

        @history    humkyung 2018.08.23 change scenePos to connector's center when symbol is placed on connector

    '''

    def matchSymbolToLine(self, svg, scenePos):

        from EngineeringConnectorItem import QEngineeringConnectorItem

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

        if len(items) > 0 and type(items[0]) is QEngineeringConnectorItem:

            scenePos = QPointF(items[0].center()[0], items[0].center()[1])

        matches = [item for item in self.scene.items() if (type(item) is QEngineeringLineItem) and (item.distanceTo((scenePos.x(), scenePos.y())) < 20)]

        if len(matches) == 1:

            matches[0].insertSymbol(svg, scenePos)

        else:

            transform = QTransform()

            transform.translate(scenePos.x() - svg.symbolOrigin[0], scenePos.y() - svg.symbolOrigin[1])

            svg.setTransform(transform)

            svg.loc = [round(scenePos.x() - svg.symbolOrigin[0], 1), round(scenePos.y() - svg.symbolOrigin[1], 1)]

            svg.size = [svg.boundingRect().width(), svg.boundingRect().height()]

            svg.origin = [round(scenePos.x(), 1), round(scenePos.y(), 1)]

            self.scene.addItem(svg)

        svg.transfer.onRemoved.connect(self.mainWindow.itemRemoved)

        self.scene.clearFocus()

        for item in self.scene.selectedItems():

            item.setSelected(False)

        self.setFocus()

        svg.setSelected(True)

        self.scene.setFocusItem(svg)

    '''

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

        @author kyouho

        @date   2018.07.31

    '''

    def findItemByUid(self, uid):

        from EngineeringConnectorItem import QEngineeringConnectorItem

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

        for item in items:

            if item.uid == uid:

                return item

        return None

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