HYTOS

def getRotatedChildInfo(symbolChildInfo):

    childList = symbolChildInfo.split("/")

    tempChildInfo = ""

    for index in range(len(childList)):

        child = childList[index]

        direction = int(child.split(",")[0])

        childName = child.split(",")[1]

        direction = (direction - 1) if direction > 0 else 3

        if index != 0:

            tempChildInfo = tempChildInfo + "/"

        tempChildInfo = tempChildInfo + str(direction) + "," + childName

    return tempChildInfo

def getCalculatedOriginalPoint(symbolChildInfo, symbolOriginalPoint, symbolRotatedAngle, rotateSymbolWidth, rotateSymbolHeight, originalSymbolWidth, originalSymbolHeight):

    if symbolChildInfo is None and symbolOriginalPoint is None:

                      , childInfo, originalPoint, connectionPoint):

                           , childInfo, originalPoint, connectionPoint)

    symbolChildInfo = targetSymbol.getChildInfo()

                    if symbolChildInfo is not None:

                        symbolChildInfo = getRotatedChildInfo(symbolChildInfo)

                originalPoint = getCalculatedOriginalPoint(symbolChildInfo, symbolOriginalPoint, symbolRotatedAngle, sw, sh, sow, soh)

                                              , symbolChildInfo, originalPoint, symbolConnectionPoint)

                                                                                    , symbolChildInfo, originalPoint, symbolConnectionPoint)

                                                                                            , symbolChildInfo, originalPoint, symbolConnectionPoint)

                                                                  , symbolChildInfo, originalPoint, symbolConnectionPoint)

                if symbolChildInfo is not None:

                    symbolChildInfo = getRotatedChildInfo(symbolChildInfo)

    <Compile Include="QcImageViewer.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="QtImageViewer.py">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="SymbolGenerator.py">

      <SubType>Code</SubType>

    </Compile>

import sys

from PyQt5.QtCore import Qt

from PyQt5.QtWidgets import QWidget, QApplication, QGridLayout, QLabel

from PyQt5 import QtCore, QtGui, QtWidgets

from PyQt5.QtWidgets import *

from PyQt5.QtGui import *

CROP_AREA_MIN_SIZE = 10

class QcImageViewer(QGraphicsView):

    def __init__(self, filePath, imgW, imgH):

        super().__init__()

        print("__init__")

        self.filePath = filePath

        self.selectedArea = [(0, 0),(imgW, imgH)]

        self.imgW = imgW

        self.imgH = imgH

        self.zoom = 1.0

        self.isPressCtrl = False

        #PyQt5.QtCore.QRectF(3740.953125, 1164.765625, 1479.9375, 1891.03125)

        self.initImage()

        self.setMouseTracking(True)

        #self.mousePressEvent = self.mousePressEvent

        #self.mouseReleaseEvent = self.mouseReleaseEvent

        #self.mouseDoubleClickEvent = self.mouseDoubleClickEvent

        #self.wheelEvent = self.wheelEvent

        #self.keyPressEvent = self.keyPressEvent

        #self.keyReleaseEvent = self.keyReleaseEvent

    def mousePressEvent(self, event):

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

            print("Pressed : " + str(event.x()) + ", " + str(event.y()))

            self.originPoint = event.pos()

            self.currentRect = QtCore.QRect()

            self.currentRect.setTopLeft(QtCore.QPoint(event.x(), event.y()))

    def mouseReleaseEvent(self, event):

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

            print("Released : " + str(event.x()) + ", " + str(event.y()))

            self.currentRect.setBottomRight(QtCore.QPoint(event.x(), event.y()))

            if self.currentRect.width() > CROP_AREA_MIN_SIZE and self.currentRect.height() > CROP_AREA_MIN_SIZE:

                pixmap = self.pixmap().copy(self.currentRect)

                pixmap.scaled(self.currentRect.width(), self.currentRect.height())

                print("New Size : " + str(self.currentRect.width()) + "/" + str(self.currentRect.height()))

                self.setPixmap(pixmap)

                self.resize(self.currentRect.width(), self.currentRect.height())

                self.parentWidget().resize(self.currentRect.width(), self.currentRect.height())

    def mouseDoubleClickEvent(self, event):

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

            self.initImage()

    def keyPressEvent(self, event):

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

            self.isPressCtrl = True

            print("Pressed Ctrl")

    def keyReleaseEvent(self, event):

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

            self.isPressCtrl = False

            print("Released Ctrl")

    def wheelEvent(self, event):

        if self.isPressCtrl == True:

            event.modifiers()

            print("Pressed Ctrl and Mouse Wheel")

    def initImage(self):

        self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)

        self.setScaledContents(True)

        pixmap = QPixmap(self.filePath)

        pixmap = pixmap.scaled(self.imgW, self.imgH, QtCore.Qt.KeepAspectRatioByExpanding)

        self.setPixmap(pixmap)

        self.resize(self.imgW, self.imgH)

        if self.parentWidget() is not None:

            self.parentWidget().resize(self.imgW, self.imgH)

import os.path

try:

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

    from PyQt5.QtGui import QImage, QPixmap, QPainterPath

    from PyQt5.QtWidgets import QGraphicsView, QGraphicsScene, QFileDialog

except ImportError:

    try:

        from PyQt4.QtCore import Qt, QRectF, pyqtSignal, QT_VERSION_STR

        from PyQt4.QtGui import QGraphicsView, QGraphicsScene, QImage, QPixmap, QPainterPath, QFileDialog

    except ImportError:

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

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

__version__ = '0.9.0'

class QtImageViewer(QGraphicsView):

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

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

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

    Some useful image format conversion utilities:

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

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

    Mouse interaction:

        Left mouse button drag: Pan image.

        Right mouse button drag: Zoom box.

        Right mouse button doubleclick: Zoom to show entire image.

    """

    MENU_HAND_TOOL = 0

    MENU_CROP_TOOL = 1

    MENU_ERASER_TOOL = 2

    MENU_PEN_TOOL = 3

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

    leftMouseButtonReleased = pyqtSignal(float, float)

    rightMouseButtonReleased = pyqtSignal(float, float)

    leftMouseButtonDoubleClicked = pyqtSignal(float, float)

    rightMouseButtonDoubleClicked = pyqtSignal(float, float)

    def __init__(self):

        QGraphicsView.__init__(self)

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

        self.scene = QGraphicsScene()

        self.setScene(self.scene)

        self.scene.setBackgroundBrush(Qt.gray)

        self.isPressCtrl = False

        self.factor = 1.0

        self.numScheduledScalings = 0

        self.currentMenuTool = self.MENU_HAND_TOOL

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

        self._pixmapHandle = None

        # Image aspect ratio mode.

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

        #   Qt.IgnoreAspectRatio: Scale image to fit viewport.

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

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

        self.aspectRatioMode = Qt.KeepAspectRatio

        # Scroll bar behaviour.

        #   Qt.ScrollBarAlwaysOff: Never shows a scroll bar.

        #   Qt.ScrollBarAlwaysOn: Always shows a scroll bar.

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

        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        # Stack of QRectF zoom boxes in scene coordinates.

        self.zoomStack = []

        # Flags for enabling/disabling mouse interaction.

        self.canZoom = True

        self.canPan = True

    def hasImage(self):

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

        """

        return self._pixmapHandle is not None

    def clearImage(self):

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

        """

        if self.hasImage():

            self.scene.removeItem(self._pixmapHandle)

            self._pixmapHandle = None

    def pixmap(self):

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

        :rtype: QPixmap | None

        """

        if self.hasImage():

            return self._pixmapHandle.pixmap()

        return None

    def image(self):

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

        :rtype: QImage | None

        """

        if self.hasImage():

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

        return None

    def setImage(self, image):

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

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

        :type image: QImage | QPixmap

        """

        if type(image) is QPixmap:

            pixmap = image

        elif type(image) is QImage:

            pixmap = QPixmap.fromImage(image)

        else:

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

        if self.hasImage():

            self._pixmapHandle.setPixmap(pixmap)

        else:

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

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

        self.updateViewer()

    def loadImageFromFile(self, fileName=""):

        """ Load an image from file.

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

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

        """

        if len(fileName) == 0:

            if QT_VERSION_STR[0] == '4':

                fileName = QFileDialog.getOpenFileName(self, "Open image file.")

            elif QT_VERSION_STR[0] == '5':

                fileName, dummy = QFileDialog.getOpenFileName(self, "Open image file.")

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

            image = QImage(fileName)

            self.setImage(image)

    def updateViewer(self):

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

        """

        if not self.hasImage():

            return

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

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

        else:

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

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

        #self.setFocusPolicy(Qt.StrongFocus)

        #self.setFocus(True)

    def resizeEvent(self, event):

        """ Maintain current zoom on resize.

        """

        self.updateViewer()

    def mousePressEvent(self, event):

        """ Start mouse pan or zoom mode.

        """

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

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

            if self.canPan and self.currentMenuTool == self.MENU_HAND_TOOL:

                self.setDragMode(QGraphicsView.ScrollHandDrag)

            elif self.currentMenuTool == self.MENU_CROP_TOOL:

                self.setDragMode(QGraphicsView.RubberBandDrag)

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

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

            if self.canZoom:

                self.setDragMode(QGraphicsView.RubberBandDrag)

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

        QGraphicsView.mousePressEvent(self, event)

    def mouseReleaseEvent(self, event):

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

        """

        QGraphicsView.mouseReleaseEvent(self, event)

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

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

            if self.currentMenuTool == self.MENU_CROP_TOOL:

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

                selectionBBox = self.scene.selectionArea().boundingRect().intersected(viewBBox)

                croppedImage = self.image().copy(selectionBBox.toAlignedRect())

                self.setImage(croppedImage)

            self.setDragMode(QGraphicsView.NoDrag)

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

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

            if self.canZoom:

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

                selectionBBox = self.scene.selectionArea().boundingRect().intersected(viewBBox)

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

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

                    self.zoomStack.append(selectionBBox)

                    self.updateViewer()

            self.setDragMode(QGraphicsView.NoDrag)

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

    def mouseDoubleClickEvent(self, event):

        """ Show entire image.

        """

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

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

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

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

            if self.canZoom:

                self.zoomStack = []  # Clear zoom stack.

                self.updateViewer()

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

        QGraphicsView.mouseDoubleClickEvent(self, event)

    def keyPressEvent(self, event):

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

            self.isPressCtrl = True

            print("Pressed Ctrl")

    def keyReleaseEvent(self, event):

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

            self.isPressCtrl = False

            print("Released Ctrl")

    def wheelEvent(self, event):

        if self.isPressCtrl == True:

            print("Pressed Ctrl and Mouse Wheel")

            if self.canZoom:

                print("Zoomable")

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

                numSteps = numDegrees // 15

                self.numScheduledScalings = self.numScheduledScalings + numSteps

                if self.numScheduledScalings * numSteps < 0:

                    self.numScheduledScalings = numSteps

                self.factor = 1.0 + (self.numScheduledScalings / 300.0)

                print("Factor : " + str(self.factor))

                self.scale(self.factor, self.factor)

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

                #selectionBBox = self.scene.selectionArea().boundingRect().intersected(viewBBox)

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

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

                #    self.zoomStack.append(selectionBBox)

                #    self.updateViewer()

        else:

            super().wheelEvent(event)

if __name__ == '__main__':

    import sys

    try:

        from PyQt5.QtWidgets import QApplication

    except ImportError:

        try:

            from PyQt4.QtGui import QApplication

        except ImportError:

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

    print('Using Qt ' + QT_VERSION_STR)

    def handleLeftClick(x, y):

        row = int(y)

        column = int(x)

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

    # Create the application.

    app = QApplication(sys.argv)

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

    viewer = QtImageViewer()

    viewer.loadImageFromFile()  # Pops up file dialog.

    # Handle left mouse clicks with custom slot.

    viewer.leftMouseButtonPressed.connect(handleLeftClick)

    # Show viewer and run application.

    viewer.show()

    sys.exit(app.exec_())

                 , childInfo = None, originalPoint = None, connectionPoint = None):

        self.childInfo = childInfo

    def setChildInfo(self, childInfo):

        self.childInfo = childInfo

    def getChildInfo(self):

        return self.childInfo

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'D:\Anaconda3\output\SymbolGenerator.ui'

#

# Created by: PyQt5 UI code generator 5.6

#

# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets

from PyQt5.QtWidgets import *

from PyQt5.QtGui import *

from QcImageViewer import QcImageViewer

import cv2

from QtImageViewer import QtImageViewer

class Ui_MainWindow(object):

    def setupUi(self, MainWindow):

        defaultFilePath = "D:\\Visual Studio Project\\DTIPID\\DTIPID\\DTI_PID\\DTI_PID\\res\\UY1-K-2000_P1_300dpi.png"

        defaultImg = cv2.imread("D:\\Visual Studio Project\\DTIPID\\DTIPID\\DTI_PID\\DTI_PID\\res\\UY1-K-2000_P1_300dpi.png", 1)

        _chan, imgW, imgH = defaultImg.shape[::-1]

        MainWindow.setObjectName("MainWindow")

        MainWindow.showFullScreen()

        mainWindowWidth = MainWindow.frameGeometry().width()

        mainWindowHeight = MainWindow.frameGeometry().height()

        self.centralwidget = QtWidgets.QWidget(MainWindow)

        self.centralwidget.setObjectName("centralwidget")

        self.centralwidget.setGeometry(QtCore.QRect(0, 0, mainWindowWidth, mainWindowHeight - 50))

        centralWidth = self.centralwidget.frameGeometry().width()

        centralHeight = self.centralwidget.frameGeometry().height()

        self.topWidget = QtWidgets.QWidget(self.centralwidget)

        self.topWidget.setObjectName("topWidget")

        self.topWidget.setGeometry(QtCore.QRect(0, 0, mainWindowWidth, 40))

        self.topWidget.setLayout(QHBoxLayout())

        self.initToolMenu(self.topWidget)

        self.imageWidget = QtWidgets.QWidget(self.centralwidget)

        self.imageWidget.setObjectName("imageWidget")

        self.imageWidget.setGeometry(QtCore.QRect(0, self.topWidget.y()+self.topWidget.height(), mainWindowWidth, centralHeight - 40))

        #self.scrollArea = QtWidgets.QScrollArea(self.centralwidget)

        #self.scrollArea.setGeometry(QtCore.QRect(0, 0, centralWidth, centralHeight))

        #self.scrollArea.setWidgetResizable(False)

        #self.scrollArea.setObjectName("scrollArea")

        #self.scrollArea.horizontalScrollBar().setEnabled(True)

        #self.scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

        #self.scrollArea.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

        #self.scrollAreaWidgetContents = QtWidgets.QWidget()

        #self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, imgW, imgH))

        #self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")

        centralWidth = self.centralwidget.frameGeometry().width()

        centralHeight = self.centralwidget.frameGeometry().height()

        #self.mainView = QcImageViewer(defaultFilePath, imgW, imgH)

        #self.mainView.setParent(self.scrollAreaWidgetContents)

        #self.mainView.setFocusPolicy(QtCore.Qt.StrongFocus)

        #self.centralwidget.setFocusProxy(self.mainView)

        #self.mainView.setFocus(True)

        self.mainView = QtImageViewer()

        #self.mainView.resize(imgW, imgH)

        self.mainView.resize(centralWidth, centralHeight)

        self.mainView.aspectRatioMode = QtCore.Qt.KeepAspectRatio

        self.mainView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

        self.mainView.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)

        self.mainView.canZoom = True

        self.mainView.canPan = True

        image = QImage(defaultFilePath)

        image = image.scaled(imgW, imgH)

        self.mainView.setImage(image)

        self.mainView.setParent(self.imageWidget)

        #self.imageWidget.setParent(self.centralwidget)

        #self.topWidget.setParent(self.centralwidget)

        #self.scrollArea.setWidget(self.scrollAreaWidgetContents)

        MainWindow.setCentralWidget(self.centralwidget)

        self.menubar = QtWidgets.QMenuBar(MainWindow)

        self.menubar.setGeometry(QtCore.QRect(0, 0, mainWindowWidth, 21))

        self.menubar.setObjectName("menubar")

        self.menuFile = QtWidgets.QMenu(self.menubar)

        self.menuFile.setObjectName("menuFile")

        MainWindow.setMenuBar(self.menubar)

        self.statusbar = QtWidgets.QStatusBar(MainWindow)

        self.statusbar.setObjectName("statusbar")

        MainWindow.setStatusBar(self.statusbar)

        self.actionOpen = QtWidgets.QAction(MainWindow)

        self.actionOpen.setObjectName("actionOpen")

        self.actionSave = QtWidgets.QAction(MainWindow)

        self.actionSave.setObjectName("actionSave")

        self.actionExit = QtWidgets.QAction(MainWindow)

        self.actionExit.setObjectName("actionExit")

        self.menuFile.addAction(self.actionOpen)

        self.menuFile.addAction(self.actionSave)

        self.menuFile.addAction(self.actionExit)

        self.menubar.addAction(self.menuFile.menuAction())

        self.retranslateUi(MainWindow)

        QtCore.QMetaObject.connectSlotsByName(MainWindow)

        #self.centralwidget.setFocus(True)

        #self.centralwidget.setFocusPolicy(QtCore.Qt.StrongFocus)

        #self.centralwidget.keyPressEvent = self.centralKeyPressEvent

    def retranslateUi(self, MainWindow):

        _translate = QtCore.QCoreApplication.translate

        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))

        self.menuFile.setTitle(_translate("MainWindow", "File"))

        self.actionOpen.setText(_translate("MainWindow", "Open"))

        self.actionSave.setText(_translate("MainWindow", "Save"))

        self.actionExit.setText(_translate("MainWindow", "Exit"))

    #def centralKeyPressEvent(self, event):

    #    print("Central Widget Key Pressed")

    def initToolMenu(self, topWidget):

        layout = topWidget.layout()

        saveTool = QPushButton()

        saveTool.setText("Save Tool")

        saveTool.mousePressEvent = self.saveToolClickEvent

        layout.addWidget(saveTool)

        layout = topWidget.layout()

        handTool = QPushButton()

        handTool.setText("Hand Tool")

        handTool.mousePressEvent = self.handToolClickEvent

        layout.addWidget(handTool)

        cropTool = QPushButton()

        cropTool.setText("Crop Tool")

        cropTool.mousePressEvent = self.cropToolClickEvent

        layout.addWidget(cropTool)

        eraserTool = QPushButton()

        eraserTool.setText("Eraser Tool")

        eraserTool.mousePressEvent = self.eraserToolClickEvent

        layout.addWidget(eraserTool)

        penTool = QPushButton()

        penTool.setText("Pen Tool")

        penTool.mousePressEvent = self.penToolClickEvent

        layout.addWidget(penTool)

    def handToolClickEvent(self, event):

        print("hand tool clicked")

        self.mainView.currentMenuTool = QtImageViewer.MENU_HAND_TOOL

    def cropToolClickEvent(self, event):

        print("crop tool clicked")

        self.mainView.currentMenuTool = QtImageViewer.MENU_CROP_TOOL

    def eraserToolClickEvent(self, event):

        print("eraser tool clicked")

        self.mainView.currentMenuTool = QtImageViewer.MENU_ERASER_TOOL

    def penToolClickEvent(self, event):

        print("pen tool clicked")

        self.mainView.currentMenuTool = QtImageViewer.MENU_PEN_TOOL

if __name__ == "__main__":

    import sys

    app = QtWidgets.QApplication(sys.argv)

    MainWindow = QtWidgets.QMainWindow()

    ui = Ui_MainWindow()

    ui.setupUi(MainWindow)

    MainWindow.show()

    sys.exit(app.exec_())

SSUB_CHILD = "CHILD"

def getConvertedChildInfo(childInfo):

    childList = childInfo.split("/")

    for index in range(len(childList)):

        child = childList[index]

        direction = int(child.split(",")[0])

        childName = child.split(",")[1]

        if index != 0:

            ret = ret + "/"

        directionCode = getDirectionCode(direction)

        ret = ret + directionCode + "," + childName

    return ret

def getDirectionCode(direction):

    ret = ""

    if direction == 0:

        ret = "U"

    elif direction == 1:

        ret = "R"

    elif direction == 2:

        ret = "D"

        ret = "L"

    sChildInfo = symbol.getChildInfo()

    if sChildInfo is not None:

        sChildInfoNode = Element(SSUB_CHILD)

        sChildInfoNode.text = getConvertedChildInfo(sChildInfo)

        sCategoryNode.append(sChildInfoNode)

                 , childInfo = None, originalPoint = None, connectionPoint = None):

                            , childInfo, originalPoint, connectionPoint)