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 = ''

    '''

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

    '''

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

        #from EngineeringConnectorItem import QEngineeringConnectorItem

        if self.hasImage():

            self.zoomStack = []

            self.updateViewer()

            self.setCursor(QCursor(Qt.ArrowCursor))

            #for conn in [item for item in self.scene().items() if type(item) is QEngineeringConnectorItem]:

            #    conn.setVisible(False)

    '''

        @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

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

            self.scene().clearSelection()

            if self.zoomStack:

                zoomNewRect = self.zoomStack.pop()

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

            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:

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

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

                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 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 occurred({}) 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):

        from TrainingEditorDialog import QTrainingEditorDialog

        from TrainingSymbolEditorDialog import QTrainingSymbolEditorDialog

        try:

            if 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 or type(self.mainWindow) is QTrainingSymbolEditorDialog:

                self.mainWindow.keyPressEvent(event)

            QGraphicsView.keyPressEvent(self, event)

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

        import symbol

        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

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

        name = event.mimeData().text()

        svg = QtImageViewer.createSymbolObject(name)

        QtImageViewer.matchSymbolToLine(self.scene(), svg, scenePos)

        if svg:

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

        """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, None, None, connPts, symbol.getBaseSymbol(),

                        symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

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

        from EngineeringConnectorItem import QEngineeringConnectorItem

        from EngineeringLineItem import QEngineeringLineItem

        from SymbolSvgItem import SymbolSvgItem

        import math

        from App import App

        try:

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

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

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

            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 False:  # len(matches) == 1:

                matches[0].insertSymbol(svg, scenePos)

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

                # item assistant with line 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)

                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)

                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

                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:

                svg.angle = angle if angle else 0.0

                svg.flip = flip if flip else 0

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

                svg.origin = [round(scenePos.x(), 1), round(scenePos.y(), 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)

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