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

        # self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        # self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        # 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

        # set currentAttribute

        self.currentAttribute = ''

        # image stack for symboleditor

        self._image_stack = []

        self._image_stack_index = -1

    '''

        @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, clear_object=True):

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

            if clear_object:

                self.scene().clear()

            if self.hasImage():

                self._pixmapHandle.setPixmap(pixmap)

            else:

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

                self._pixmapHandle.setFlags(QGraphicsItem.ItemClipsChildrenToShape)

                self._pixmapHandle.setZValue(-1)

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

            self.updateViewer()

        except Exception as ex:

            print('error occurred({}) 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, drawing):

        import cv2

        import numpy as np

        from AppDocData import AppDocData

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

        """

        file_path = None

        try:

            app_doc_data = AppDocData.instance()

            cvImg = None

            if drawing:

                file_path = drawing.file_path

                cvImg = drawing.image

            else:

                options = QFileDialog.Options()

                options |= QFileDialog.DontUseNativeDialog

                if QT_VERSION_STR[0] == '4':

                    file_path = QFileDialog.getOpenFileName(self, "Open image file",

                                                            app_doc_data.project.getDrawingFilePath(),

                                                            "Image files(*.png *.jpg)", options=options)

                elif QT_VERSION_STR[0] == '5':

                    file_path, _ = QFileDialog.getOpenFileName(self, "Open image file",

                                                               app_doc_data.project.getDrawingFilePath(),

                                                               "Image files(*.png *.jpg)", options=options)

                _bytes = None

                with open(file_path.encode('utf-8'), 'rb') as stream:

                    _bytes = stream.read()

                numpyArray = np.asarray(bytearray(_bytes), dtype=np.uint8)

                image = cv2.imdecode(numpyArray, cv2.IMREAD_UNCHANGED)

                cvImg = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

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

                configs = app_doc_data.getConfigs('Filter', 'DilateSize')

                if 1 == len(configs) and int(configs[0].value) is not 0:

                    size = int(configs[0].value)

                    kernel = np.ones((size, size), np.uint8)

                    cvImg = cv2.erode(cvImg, kernel, iterations=1)

                configs = app_doc_data.getConfigs('Filter', 'FlatSize')

                if 1 == len(configs) and int(configs[0].value) is not 0:

                    size = int(configs[0].value)

                    kernel = np.ones((size, size), np.uint8)

                    cvImg = cv2.morphologyEx(cvImg, cv2.MORPH_CLOSE, kernel)

                    cvImg = cv2.morphologyEx(cvImg, cv2.MORPH_OPEN, kernel)

            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:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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 file_path

    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)

    '''

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

    '''

    def updateViewer(self, zoomNewRect=None):

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

        if not self.hasImage():

            return

        if zoomNewRect is not None:

            self.fitInView(zoomNewRect, Qt.KeepAspectRatio)

        else:

            if self.zoomStack:

                if zoomNewRect is None:

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

        if isZoomIn:

            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)

            zoomArea = QRectF(left_top, right_bottom)

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

            if zoomArea.isValid():

                self.zoomStack.append(zoomArea)

                self.updateViewer(zoomArea)

        else:

            zoomNewRect = None

            self.scene().clearSelection()

            if self.zoomStack:

                clickPos = self.mapToScene(clickPos.x(), clickPos.y())

                zoomNewRect = self.zoomStack.pop()

                zoomNewRect = QRectF(clickPos.x() - zoomNewRect.width() / 2, clickPos.y() - zoomNewRect.height() / 2, zoomNewRect.width(), zoomNewRect.height())

            else:

                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)

                zoomArea = QRectF(left_top, right_bottom)

                self.scene().clearSelection()

                if zoomArea.isValid():

                    zoomNewRect = zoomArea

            self.updateViewer(zoomNewRect)

    '''

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

                    event.accept()

                    return

        except Exception as ex:

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

                                                       sys.exc_info()[-1].tb_lineno))

        if self.scene().guidesEnabled:

            self.scene().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:

                # for symboleditor

                if self.window().objectName() == 'SymbolEditorDialog':

                    self._image_stack_index = self._image_stack_index + 1

                    self._image_stack.insert(self._image_stack_index, self.image().copy())

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

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

                if self.command.isTreated:

                    event.accept()

                    return

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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

            else:

                QGraphicsView.mouseReleaseEvent(self, event)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occurred({}) in {}:{}'.format(repr(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      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):

        from TrainingEditorDialog import QTrainingEditorDialog

        from TrainingSymbolEditorDialog import QTrainingSymbolEditorDialog

        try:

            #print('view : ' + str(event.key()))

            if event.key() == Qt.Key_Escape or event.key() == Qt.Key_Return:

                if self.command is not None:

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

                    if self.command.isTreated:

                        self.command = DefaultCommand.DefaultCommand(self)

                        return

            else:

                if self.command is not None:

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

                    if self.command.isTreated: return

            if type(self.mainWindow) is QTrainingEditorDialog or type(self.mainWindow) is QTrainingSymbolEditorDialog:

                self.mainWindow.keyPressEvent(event)

            #print(QApplication.keyboardModifiers() == Qt.ControlModifier)

            QGraphicsView.keyPressEvent(self, event)

        except Exception as ex:

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

                      f"{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, 1.5)

                    elif numDegrees.y() < 0:

                        self.zoomImage(False, event, 0.5)

        else:

            super().wheelEvent(event)

    '''

        @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 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') and self._underItem in self.scene().items():

                        self._underItem.highlight(False)

                    else:

                        self._underItem = None

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

        """drop a symbol"""

        from AppDocData import AppDocData

        from EngineeringEndBreakItem import QEngineeringEndBreakItem

        from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

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

            return

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

            self._underItem.hoverLeaveEvent(None)

            self._underItem = None

        else:

            self._underItem = None

        for item in self.scene().selectedItems():

            item.clearFocus()

            item.setSelected(False)

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

        name = event.mimeData().text()

        svg = QtImageViewer.createSymbolObject(name, event.mimeData().tag.getScale())

        fixedAngle = 0.0 if QApplication.keyboardModifiers() == Qt.ControlModifier else None

        QtImageViewer.matchSymbolToLine(self.scene(), svg, scenePos, angle=fixedAngle)

        if svg:

            if type(svg) is QEngineeringEndBreakItem or type(svg) is QEngineeringSpecBreakItem:

                svg.set_property('Freeze', True)

            svg.setSelected(True)

            svg.setFocus()

            self.setFocus()  # set focus to graphicview

        event.acceptProposedAction()

    '''

        @brief  drop create Symbol

        @author kyouho

        @date   2018.07.27

    '''

    @staticmethod

    def createSymbolObject(name, scale=[1.0, 1.0]):

        """create a symbol object has given uid"""

        from AppDocData import AppDocData

        app_doc_data = AppDocData.instance()

        symbol = app_doc_data.getSymbolByQuery('name', name)

        if symbol:

            svg_file_name = symbol.sName

            svgFilePath = os.path.join(app_doc_data.getCurrentProject().getSvgFilePath(), symbol.getType(),

                                    svg_file_name + '.svg')

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

            connPts = None

            strConnPts = symbol.getConnectionPoint()

            if strConnPts is not None and strConnPts != '':

                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(svg_file_name, symbol.getType(), 0, None, [symbol.width, symbol.height], None, connPts, symbol.getBaseSymbol(),

                        symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel(), None, scale)

            return svg

        else:

            return None

    '''

        @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

    '''

    @staticmethod

    def matchSymbolToLine(scene, svg, scenePos, angle=None, flip=None, strict=False, auto=False, move=False):

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        from EngineeringUnknownItem import QEngineeringUnknownItem

        from EngineeringAbstractItem import QEngineeringAbstractItem

        import math

        from App import App

        from AppDocData import AppDocData

        try:

            if not svg.scene():

                svg.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

            items = [item for item in scene.items(scenePos) if type(item) is not QEngineeringUnknownItem and \

                    type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem and item is not svg]

            connectors = []

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

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

                connectors = [connector for connector in items if issubclass(type(connector.parentItem()), SymbolSvgItem) \

                                and type(connector) is QEngineeringConnectorItem]

                if not connectors:

                    connectors = [connector for connector in items if type(connector.parentItem()) is QEngineeringLineItem \

                                        and type(connector) is QEngineeringConnectorItem]

            #matches = [item for item in scene.items() if

            #        (type(item) is QEngineeringLineItem) and (item.distanceTo((scenePos.x(), scenePos.y())) < 20)]

            allowed_error = 0.0001

            if len(connectors) == 1 and len(svg.connectors) >= 2 and len(connectors[0].parentItem().connectors):

                if move:

                    svg.scene().removeItem(svg)

                    svg.resetPosition()

                # item assistant with connection

                xl = connectors[0].parentItem().symbolOrigin[0] - connectors[0].connectPoint[0]

                yl = connectors[0].parentItem().symbolOrigin[1] - connectors[0].connectPoint[1]

                length = math.sqrt(xl * xl + yl * yl)

                if length < allowed_error:

                    return

                ddx = (connectors[0].sceneBoundingRect().center().x() - connectors[0].parentItem().origin[0]) / length

                ddy = (connectors[0].sceneBoundingRect().center().y() - connectors[0].parentItem().origin[1]) / length

                dx, dy = abs(svg.connectors[1].connectPoint[0] - svg.symbolOrigin[0]), abs(svg.connectors[1].connectPoint[1] - svg.symbolOrigin[1])

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

                if length < allowed_error:

                    return

                dx, dy = length * ddx, length * ddy

                # if abs(connectors[0].parentItem().angle - math.pi / 2) < allowed_error or abs(connectors[0].parentItem().angle - math.pi / 2 * 3) < allowed_error:

                #    dx, dy = ddx * dy, ddy * dx

                # else:

                #    dx, dy = ddx * dx, ddy * dy

                xxl = connectors[0].parentItem().origin[0] - connectors[0].center()[0]

                yyl = connectors[0].parentItem().origin[1] - connectors[0].center()[1]

                rAngle = -math.atan2(yyl, xxl)# if flip == 0 else math.atan2(yl, xl)

                rAngle = abs(rAngle) if rAngle < 0 + allowed_error else 2 * math.pi - rAngle

                if angle is not None:

                    rAngle = angle

                svg.angle = rAngle

                x, y = connectors[0].sceneBoundingRect().center().x() + dx, \

                    connectors[0].sceneBoundingRect().center().y() + dy

                svg.loc = [x - svg.symbolOrigin[0], y - svg.symbolOrigin[1]]

                svg.origin = [x, y]

                svg.addSvgItemToScene(scene, True if not auto else False)

                items = [item for item in scene.items(scenePos) if

                        type(item) is not QGraphicsPixmapItem and type(item) is not QGraphicsTextItem]

                items = [item for item in items if item.parentItem() is svg and type(item) is QEngineeringConnectorItem]

                if items and connectors[0].connectedItem and type(connectors[0].connectedItem) is QEngineeringLineItem:

                    items[0].connect(connectors[0].parentItem())

                    anotherConns = [conn for conn in svg.connectors if conn is not items[0]]

                    anotherConns[0].connect(connectors[0].connectedItem)

                    for lineConn in connectors[0].connectedItem.connectors:

                        if lineConn.connectedItem is connectors[0].parentItem():

                            lineConn.connect(svg)

                            lineConn.setPos(anotherConns[0].center())

                            break

                    connectors[0].connect(svg)

                    lineConn.transfer.onPosChanged.emit(lineConn)

                elif items:

                    items[0].connect(connectors[0].parentItem())

                    #items[0].highlight(False)

                    if connectors[0].connectedItem:

                        for conn in connectors[0].connectedItem.connectors:

                            if conn.connectedItem is connectors[0].parentItem():

                                conn.connect(None)

                                #conn.highlight(False)

                                break

                    connectors[0].connect(svg)

                    #connectors[0].highlight(False)

            elif not strict and len(items) == 1 and type(items[0]) is QEngineeringLineItem and items[0].length() > svg.size[0] and items[0].length() > svg.size[1]:

                if move:

                    svg.scene().removeItem(svg)

                    svg.resetPosition()

                vec = items[0].perpendicular()

                line = [(scenePos.x() - vec[0] * 20, scenePos.y() - vec[1] * 20), (scenePos.x() + vec[0] * 20, scenePos.y() + vec[1] * 20)]

                origin = items[0].intersection(line)

                configs = AppDocData.instance().getConfigs('Data', 'Grid')

                grid = int(configs[0].value) if 1 == len(configs) else -1

                if grid == 1:

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

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

                    '''

                    if not svg.symbolConvertingOrigin:

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

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

                    else:

                        svg.origin = [round(origin.x - svg.symbolConvertingOrigin[0] + svg.symbolOrigin[0]), round(origin.y - svg.symbolConvertingOrigin[1] + svg.symbolOrigin[1])]

                        svg.loc = [round(origin.x - svg.symbolConvertingOrigin[0]), round(origin.y - svg.symbolConvertingOrigin[1])]

                    '''

                else:

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

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

                    '''

                    if not svg.symbolConvertingOrigin:

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

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

                    else:

                        svg.origin = [round(origin.x - svg.symbolConvertingOrigin[0] + svg.symbolOrigin[0], 1), round(origin.y - svg.symbolConvertingOrigin[1] + svg.symbolOrigin[1], 1)]

                        svg.loc = [round(origin.x - svg.symbolConvertingOrigin[0], 1), round(origin.y - svg.symbolConvertingOrigin[1], 1)]

                    '''

                svg.angle = items[0].angle()

                if items[0].start_point()[1] - items[0].end_point()[1] > 0:

                    svg.angle = math.pi - svg.angle

                svg.addSvgItemToScene(scene, True if not auto else False, True)

                if len(svg.connectors) > 1:

                    connectors = [svg.connectors[0], svg.connectors[1]]

                    connectors.sort(key=lambda x: abs(x.center()[0] - items[0].connectors[0].center()[0]) + abs(x.center()[1] - items[0].connectors[0].center()[1]))

                    savedConnectors = []

                    for _connector in items[0].connectors:

                        if _connector.connectedItem and _connector._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT:

                            _connectors2 = [_connector2 for _connector2 in _connector.connectedItem.connectors if _connector2.connectedItem is items[0] and _connector2._connected_at == QEngineeringAbstractItem.CONNECTED_AT_PT]

                            if _connectors2:

                                savedConnectors.append(_connectors2[0])

                                continue

                        savedConnectors.append(None)

                    inLine = QEngineeringLineItem(vertices=[items[0].start_point(), connectors[0].center()])

                    inLine.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                    inLine.lineType = items[0].lineType

                    outLine = QEngineeringLineItem(vertices=[connectors[1].center(), items[0].end_point()])

                    outLine.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                    outLine.lineType = items[0].lineType

                    inLine.connectors[0].connect(items[0].connectors[0].connectedItem, items[0].connectors[0]._connected_at)

                    inLine.connectors[1].connect(svg)

                    connectors[0].connect(inLine)

                    outLine.connectors[0].connect(svg)

                    outLine.connectors[1].connect(items[0].connectors[1].connectedItem, items[0].connectors[1]._connected_at)

                    connectors[1].connect(outLine)

                    if savedConnectors[0]:

                        savedConnectors[0].connect(inLine)

                    if savedConnectors[1]:

                        savedConnectors[1].connect(outLine)

                    scene.addItem(inLine)

                    scene.addItem(outLine)

                    items[0].transfer.onRemoved.emit(items[0])

            elif not strict and not move:

                svg.angle = angle if angle else 0.0

                svg.flip = flip if flip else 0

                configs = AppDocData.instance().getConfigs('Data', 'Grid')

                grid = int(configs[0].value) if 1 == len(configs) else -1

                if grid == 1:

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

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

                    '''

                    if not svg.symbolConvertingOrigin:

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

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

                    else:

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

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

                    '''

                else:

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

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

                    '''

                    if not svg.symbolConvertingOrigin:

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

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

                    else:

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

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

                    '''

                if len(svg.connectors) == 1:

                    # single connection item assistant

                    connectors = [connector for connector in connectors if connector.parentItem() is not svg and not connector.connectedItem]

                    if len(connectors) == 1:

                        xxl = connectors[0].parentItem().origin[0] - connectors[0].center()[0]

                        yyl = connectors[0].parentItem().origin[1] - connectors[0].center()[1]

                        rAngle = -math.atan2(yyl, xxl)

                        rAngle = abs(rAngle) if rAngle < 0 + allowed_error else 2 * math.pi - rAngle

                        rAngle = rAngle + math.pi if rAngle + math.pi < 2 * math.pi else rAngle - math.pi

                        svg.angle = rAngle

                        svg.connectors[0].connect(connectors[0].parentItem())

                        #svg.connectors[0].highlight(False)

                        connectors[0].connect(svg)

                        #items[0].highlight(False)

                svg.addSvgItemToScene(scene, True if not auto else False, True)

            # svg.reSettingConnetors()

            '''

            if not strict:

                # need fix

                App.mainWnd().symbolTreeWidget.clearFocus()

                scene.setFocus()

                #scene.clearFocus()

                for item in scene.selectedItems():

                    item.setSelected(False)

                svg.setSelected(True)

                scene.setFocusItem(svg)

            '''

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

        from EngineeringConnectorItem import QEngineeringConnectorItem

        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 convertQImageToMat(self, incomingImage):

        '''Converts a QImage into an opencv MAT format'''

        import numpy as np

        try:

            incomingImage = incomingImage.convertToFormat(QImage.Format_RGBA8888)

            width = incomingImage.width()

            height = incomingImage.height()

            ptr = incomingImage.bits()

            ptr.setsize(incomingImage.byteCount())

            arr = np.array(ptr).reshape(height, width, 4)  # Copies the data

            return arr

        except Exception as ex:

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

                                                       sys.exc_info()[-1].tb_lineno))

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