HYTOS

            trainingFileList = os.listdir(path)

            trainingFileList.sort()

        return trainingFileList

    def getTrainingSymbolFileList(self):

        """  Get Symbol Training file list """

        try:

            project = AppDocData.instance().getCurrentProject()

            path = project.getTrainingSymbolFilePath()

            symbolTrainingFileList = os.listdir(path)

            symbolTrainingFileList.sort()

        except Exception as ex:

            from App import App

            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)

        return symbolTrainingFileList

from TrainingSymbolImageListDialog import QTrainingSymbolImageListDialog

            self.actionSymbol_Training.triggered.connect(self.symbolTrainingClicked)

            self.actionSymbol_Training.setVisible(False)

    def symbolTrainingClicked(self):

        try:

            dialog = QTrainingSymbolImageListDialog(self)

            dialog.exec_()

        except Exception as ex:

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

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

            self.addMessage.emit(MessageType.Error, message)

# Form implementation generated from reading ui file './UI/MainWindow.ui'

# Created by: PyQt5 UI code generator 5.11.3

        self.actionSymbol_Training = QtWidgets.QAction(MainWindow)

        self.actionSymbol_Training.setObjectName("actionSymbol_Training")

        self.menu_2.addSeparator()

        self.menu_2.addAction(self.actionSymbol_Training)

        self.actionSymbol_Training.setText(_translate("MainWindow", "Symbol Training"))

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

    def getTrainingSymbolFilePath(self):

        """ return symbol training path """

        return os.path.join(self.getPath(), 'Training_Symbol')

        trainingSymbolPath = self.getTrainingSymbolFilePath()

        if not os.path.exists(trainingSymbolPath):

            os.makedirs(trainingSymbolPath)

from AppDocData import *

from AppDocData import *

            grid_size[0] = grid_size[0] + space * 2

            grid_size[1] = grid_size[1] + space * 2

# coding: utf-8

import sys

import os, time, datetime

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import *

import TrainingEditor_UI

import QtImageViewer

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from TrainingBoxItem import QTrainingBoxItem

import cv2

import numpy as np

from PIL import Image

import AreaZoomCommand

import PlaceLineCommand

class QTrainingSymbolEditorDialog(QDialog):

    def __init__(self, parent, trainingImgPath, trainingBoxPath, boundaryOcrData, dateItem, boxItem):

        self.spinBoxFlag = False

        QDialog.__init__(self, parent)

        self.setWindowFlag(Qt.WindowMinMaxButtonsHint)

        self.trainingImgPath = trainingImgPath

        self.trainingBoxPath = trainingBoxPath

        self.boundaryOcrData = boundaryOcrData

        self.dateItem = dateItem

        self.boxItem = boxItem

        self.isChanged = False

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        self.ui = TrainingEditor_UI.Ui_TrainingEditorDialog()

        self.ui.setupUi(self)

        self.graphicsViewTrainingDrawing = QtImageViewer.QtImageViewer(self)

        self.graphicsViewTrainingDrawing.setParent(self.ui.centralWidget)

        self.graphicsViewTrainingDrawing.useDefaultCommand()

        self.ui.verticalLayoutTrainingDrawing.addWidget(self.graphicsViewTrainingDrawing)

        self.graphicsViewZoomDrawing = QGraphicsView(self)

        self.graphicsViewZoomDrawing.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        self.graphicsViewZoomDrawing.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

        self.graphicsViewZoomDrawing.setParent(self.ui.leftSideWidget)

        self.ui.horizontalLayoutZoomDrawing.addWidget(self.graphicsViewZoomDrawing)

        # 학습 이미지 읽어서 메인 뷰에 그림, 사이드 뷰에 추가

        try:

            #trainingImgPath = os.path.join(project.getTrainingFilePath(), 'seed.seedF.exp0.tif')

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

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

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

            bytesPerLine = cvImg.shape[1]

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

            self.graphicsViewTrainingDrawing.setImage(image)

            # 사이드 뷰

            if type(image) is QPixmap:

                pixmap = image

            elif type(image) is QImage:

                pixmap = QPixmap.fromImage(image)

            scene = QGraphicsScene()

            self.graphicsViewZoomDrawing.setScene(scene)

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

            self.graphicsViewZoomDrawing.scene().setSceneRect(0, 0, pixmap.width(), pixmap.height())

            self.graphicsViewZoomDrawing.fitInView(self.graphicsViewZoomDrawing.scene().sceneRect(), Qt.KeepAspectRatioByExpanding)

            rect = QGraphicsRectItem(0, 0, 0, 0)

            pen = QPen(Qt.SolidLine)

            pen.setColor(Qt.green)

            pen.setWidthF(1)

            pen.setJoinStyle(Qt.MiterJoin)

            rect.setPen(pen)

            rect.setOpacity(0.7)

            self.graphicsViewZoomDrawing.scene().addItem(rect)

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

        # 박스 읽어서 메인 뷰에 그림

        try:

            boxList = []

            if self.boundaryOcrData is None:

                fBox = open(trainingBoxPath, 'r', encoding='utf8')

                SBox = fBox.read()

                fBox.close()

                boxList = SBox.split('\n')

            else:

                boxList = boundaryOcrData.split('\n')

            for box in boxList:

                if box == '': continue

                boxComponent = box.split(' ')

                singleBox = QTrainingBoxItem(str(boxComponent[0]), int(boxComponent[1]), cvImg.shape[0] - int(boxComponent[4]), int(boxComponent[3]) - int(boxComponent[1]), int(boxComponent[4]) - int(boxComponent[2]))

                singleBox.transfer.onRemoved.connect(self.itemRemoved)

                singleBox.addTextItemToScene(self.ui, self.graphicsViewTrainingDrawing, self.graphicsViewZoomDrawing, self.spinBoxFlag)

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

        self.removedItems = []

        self.ui.pushButtonZoom.clicked.connect(self.onAreaZoom)

        self.ui.pushButtonSave.clicked.connect(self.pushButtonSaveClicked)

        self.ui.pushButtonCancel.clicked.connect(self.pushButtonCancelClicked)

        self.ui.pushButtonDelete.clicked.connect(self.pushButtonDeleteClicked)

        self.ui.pushButtonAdd.clicked.connect(self.pushButtonAddClicked)

        self.ui.pushButtonSplit.clicked.connect(self.pushButtonSplitClicked)

        self.ui.spinBoxLeft.valueChanged.connect(self.spinBoxChangedEvent)

        self.ui.spinBoxTop.valueChanged.connect(self.spinBoxChangedEvent)

        self.ui.spinBoxWidth.valueChanged.connect(self.spinBoxChangedEvent)

        self.ui.spinBoxHeight.valueChanged.connect(self.spinBoxChangedEvent)

        self.ui.lineEditChar.returnPressed.connect(self.pushButtonChangeClicked)

    '''

        @brief      split boxitem by button click

        @author     euisung

        @date       2018.10.31

    '''

    def pushButtonSplitClicked(self):

        self.isChanged = True

        items = self.graphicsViewTrainingDrawing.scene.selectedItems()

        if len(items) is not 1:

            return

        rect = items[0].rect()

        secondBox = QTrainingBoxItem('', rect.x() + round(rect.width() / 2), rect.y(), round(rect.width() / 2), rect.height())

        secondBox.transfer.onRemoved.connect(self.itemRemoved)

        secondBox.addTextItemToScene(self.ui, self.graphicsViewTrainingDrawing, self.graphicsViewZoomDrawing, self.spinBoxFlag)

        items[0].setRect(rect.x(), rect.y(), round(rect.width() / 2), rect.height())

    '''

        @brief      add boxitem by button click

        @author     euisung

        @date       2018.10.17

    '''

    def pushButtonAddClicked(self):

        self.isChanged = True

        items = self.graphicsViewTrainingDrawing.scene.selectedItems()

        allItems = self.graphicsViewTrainingDrawing.scene.items()

        totalWidth = 0

        totalHeight = 0

        count = 0

        if len(items) is 1:

            rect = items[0].rect()

        elif len(allItems) > 1:

            for item in allItems:

                if type(item) is QGraphicsPixmapItem:

                    x = int(item.boundingRect().width() / 2)

                    y = int(item.boundingRect().height()/ 2)

                elif hasattr(item, 'rect'):

                    count += 1

                    totalWidth += item.rect().width()

                    totalHeight += item.rect().height()

            rect = QRectF(x, y, round(totalWidth / count), round(totalHeight / count))

        else:

            for item in allItems:

                if type(item) is QGraphicsPixmapItem:

                    x = int(item.boundingRect().width() / 2)

                    y = int(item.boundingRect().height()/ 2)

            rect = QRectF(x, y, 5, 10)

        singleBox = QTrainingBoxItem('', rect.x() + 3, rect.y(), rect.width(), rect.height())

        singleBox.transfer.onRemoved.connect(self.itemRemoved)

        singleBox.addTextItemToScene(self.ui, self.graphicsViewTrainingDrawing, self.graphicsViewZoomDrawing, self.spinBoxFlag)

    '''

        @brief      delete boxitem by button click

        @author     euisung

        @date       2018.10.17

    '''

    def pushButtonDeleteClicked(self):

        self.isChanged = True

        items = self.graphicsViewTrainingDrawing.scene.selectedItems()

        for item in items:

            item.transfer.onRemoved.emit(item)

    def onCharChanged(self, text):

        """

        change lineedit's text with given text

        """

        if text:

            self.ui.lineEditChar.setText(text)

            self.pushButtonChangeClicked()

    '''

        @brief      change boxitem char by button click

        @author     euisung

        @date       2018.10.17

    '''

    def pushButtonChangeClicked(self):

        self.isChanged = True

        items = self.graphicsViewTrainingDrawing.scene.selectedItems()

        if len(items) is not 1:

            return

        items[0].char = self.ui.lineEditChar.text()

        items[0].textShowBox.setHtml(self.ui.lineEditChar.text())

    '''

        @brief      close dialog by button click

        @author     euisung

        @date       2018.10.17

    '''

    def pushButtonCancelClicked(self):

        if self.isChanged:

            reply = QMessageBox.question(self, self.tr('Continue?'), self.tr('Changes may not have been saved.'), QMessageBox.Ignore, QMessageBox.Cancel)

            if reply == QMessageBox.Ignore:

                QDialog.reject(self)

        else:

            QDialog.reject(self)

    '''

        @brief      save box item by button click

        @author     euisung

        @date       2018.10.16

    '''

    def pushButtonSaveClicked(self):

        items = self.graphicsViewTrainingDrawing.scene.items()

        outBox = ""

        for item in items:

            if type(item) is QGraphicsPixmapItem:

                imgHeight = int(item.boundingRect().height())

                imgWidth = int(item.boundingRect().width())

        for item in items:

            if type(item) is QTrainingBoxItem:

                rect = item.rect()

                char, x, y, width, height = item.char, int(rect.x()), int(rect.y()), int(rect.width()), int(rect.height())

                bx, by, bx2, by2 = str(x), str(imgHeight - y - height), str(x + width), str(imgHeight - y)

                if char == '':

                    continue

                outBox += char + " " + bx + " " + by + " " + bx2 + " " + by2 + "\n"

        fw = open(self.trainingBoxPath, 'w')

        fw.write(outBox)

        fw.close()

        modifiedTime = str(datetime.datetime.strptime(time.ctime(os.path.getmtime(self.trainingBoxPath)), "%a %b %d %H:%M:%S %Y"))

        self.dateItem.setText(modifiedTime)

        boxContent = outBox.split('\n')

        boxContent = boxContent[:-1]

        boxchars = ''

        for char in boxContent:

            boxchars += char[0]

        self.boxItem.setText(boxchars)

        self.isChanged = False

        reply = QMessageBox.information(self, self.tr('Information'), self.tr('Save Success!'), QMessageBox.Ok, QMessageBox.Cancel)

        if reply == QMessageBox.Ok:

            QDialog.reject(self)

    '''

        @brief      chane box item's rect by button click

        @author     euisung

        @date       2018.10.16

    '''

    def spinBoxChangedEvent(self, event):

        self.isChanged = True

        items = self.graphicsViewTrainingDrawing.scene.selectedItems()

        if (len(items) is not 1) or self.spinBoxFlag:

            return

        spinBoxName = self.sender().objectName()

        rect = items[0].rect()

        bound = self.graphicsViewZoomDrawing.scene().items()[0]

        if spinBoxName == 'spinBoxLeft':

            spinBoxValue = self.ui.spinBoxLeft.value()

            items[0].setRect(QRectF(spinBoxValue, rect.y(), rect.width(), rect.height()))

            items[0].textShowBox.setPos(items[0].rect().x() + round(items[0].rect().width() / 3), items[0].rect().y() - round(items[0].rect().height() / 2))

        elif spinBoxName == 'spinBoxTop':

            spinBoxValue = self.ui.spinBoxTop.value()

            items[0].setRect(QRectF(rect.x(), spinBoxValue, rect.width(), rect.height()))

            items[0].textShowBox.setPos(items[0].rect().x() + round(items[0].rect().width() / 3), items[0].rect().y() - round(items[0].rect().height() / 2))

        elif spinBoxName == 'spinBoxWidth':

            spinBoxValue = self.ui.spinBoxWidth.value()

            items[0].setRect(QRectF(rect.x(),  rect.y(), spinBoxValue, rect.height()))

            items[0].textShowBox.setPos(items[0].rect().x() + round(items[0].rect().width() / 3), items[0].rect().y() - round(items[0].rect().height() / 2))

        elif spinBoxName == 'spinBoxHeight':

            spinBoxValue = self.ui.spinBoxHeight.value()

            items[0].setRect(QRectF(rect.x(), rect.y(), rect.width(), spinBoxValue))

            items[0].textShowBox.setPos(items[0].rect().x() + round(items[0].rect().width() / 3), items[0].rect().y() - round(items[0].rect().height() / 2))

        rect = items[0].rect()        

        bound.setRect(rect)

        rectSide = QRectF(rect.x() - 3, rect.y() - 3, rect.width() + 6,  rect.height() + 6)

        self.graphicsViewZoomDrawing.fitInView(rectSide)

        self.graphicsViewTrainingDrawing.scene.update()

    def onAreaZoom(self, action):

        if self.ui.pushButtonZoom.isChecked():

            cmd = AreaZoomCommand.AreaZoomCommand(self.graphicsViewTrainingDrawing)

            cmd.onRejected.connect(self.onCommandRejected)

            self.graphicsViewTrainingDrawing.command = cmd

    def onCommandRejected(self, cmd):

        try:

            if type(cmd) is AreaZoomCommand.AreaZoomCommand:

                self.ui.pushButtonZoom.setChecked(False)

        finally:

            self.graphicsViewTrainingDrawing.useDefaultCommand()

    def itemRemoved(self, item):

        try:

            if type(item) is QTrainingBoxItem:

                self.removedItems.append(str(item.uid))

            if item.scene is not None: item.scene.removeItem(item)

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

        @author     euisung

        @date       2018.11.05

    '''

    def keyPressEvent(self, event):

        try:

            items = self.graphicsViewTrainingDrawing.scene.selectedItems()

            if len(items) is not 1 or type(items[0]) is not QTrainingBoxItem:

                return

            selectedItem = items[0]

            closestItem = None

            x = selectedItem.rect().x()

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

                dx =  sys.maxsize

                for item in self.graphicsViewTrainingDrawing.scene.items():

                    if type(item) is QTrainingBoxItem:

                        if x - item.rect().x() > 0 and x - item.rect().x() < dx:

                            closestItem = item

                            dx = x - item.rect().x()

                if closestItem is not None:

                    closestItem.setSelected(True)

                    selectedItem.setSelected(False)

                    closestItem.mousePressEvent('arrow key')             

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

                dx = -sys.maxsize

                for item in self.graphicsViewTrainingDrawing.scene.items():

                    if type(item) is QTrainingBoxItem:

                        if x - item.rect().x() < 0 and x - item.rect().x() > dx:

                            closestItem = item

                            dx = x - item.rect().x()

                if closestItem is not None:

                    closestItem.setSelected(True)

                    selectedItem.setSelected(False)

                    closestItem.mousePressEvent('arrow key')

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

                self.ui.spinBoxWidth.setValue(self.ui.spinBoxWidth.value() + 1)

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

                self.ui.spinBoxWidth.setValue(self.ui.spinBoxWidth.value() - 1)

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

                pass

            elif selectedItem:

                text = event.text()

                if text: self.onCharChanged(text)

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

            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)

            return None

# coding: utf-8

""" This is symbol training image list dialog module """

import sys

import os, time, datetime, copy

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from AppDocData import *

from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse

import TrainingSymbolImageList_UI

from TrainingSymbolEditorDialog import QTrainingSymbolEditorDialog

import numpy as np

import pyqtgraph as pg

import cv2

#// for remove noise

#noisePassList = ['.', '\"', '\'', ',', '`', '-', '+']

class QTrainingSymbolImageListDialog(QDialog):

    """

    This is training image list dialog class

    """

    TRAINING_DATA_COUNT = 5

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self.setWindowFlag(Qt.WindowMinMaxButtonsHint)

        self.ui = TrainingSymbolImageList_UI.Ui_TraingingSymbolImageListDialog()

        self.ui.setupUi(self)

        self.ui.progressBar.setValue(0)

        self.labelList = []

        # for List 

        self.ui.tableWidgetList.setSelectionMode(QAbstractItemView.SingleSelection) 

        self.ui.tableWidgetList.setColumnCount(4)

        ## column header 명 설정

        self.ui.tableWidgetList.setHorizontalHeaderLabels([self.tr('No.'), self.tr('Image List'), self.tr('Modified Date'), self.tr('Label Contents')])

        self.ui.tableWidgetList.horizontalHeaderItem(1).setToolTip(self.tr('Image Name')) # header tooltip

        self.ui.tableWidgetList.horizontalHeaderItem(2).setToolTip(self.tr('Edit Status')) # header tooltip

        self.ui.tableWidgetList.horizontalHeaderItem(3).setToolTip(self.tr('Label Contents')) # header tooltip

        self.ui.tableWidgetList.horizontalHeaderItem(1).setSizeHint(QSize(30, 30))

        self.ui.tableWidgetList.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)

        self.ui.tableWidgetList.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)

        self.ui.tableWidgetList.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)

        self.ui.tableWidgetList.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch)

        self.ui.tableWidgetList.resizeColumnsToContents()

        self.ui.tableWidgetList.setEditTriggers(QAbstractItemView.NoEditTriggers)

        self.listUpdate()

        # connect signals and slots

        self.ui.tableWidgetList.cellDoubleClicked.connect(self.listCellDoubleClicked)

        self.ui.pushButtonLabel.clicked.connect(self.pushButtonLabelClicked)

        self.ui.pushButtonMakeTrainingImage.clicked.connect(self.makeTrainingImageClicked)

        self.ui.pushButtonImageDelete.clicked.connect(self.pushButtonImageDeleteClicked)

        self.ui.pushButtonLabelDelete.clicked.connect(self.pushButtonLabelDeleteClicked)

        self.ui.pushButtonClose.clicked.connect(self.pushButtonCloseClicked)

        self.ui.pushButtonDeleteBatchLabel.clicked.connect(self.pushButtonDeleteBatchLabelClicked)

        # delete character in box

        #self.ui.pushButtonDeleteBatchLabel.setEnabled(False)

        #self.ui.pushButtonDeleteBatchLabel.setHidden(True)

        #self.ui.lineEditTargetLabel.setEnabled(False)

        #self.ui.lineEditTargetLabel.setHidden(True)

        self.ui.pushButtonDeleteBatchLabel.setEnabled(True)

        self.ui.pushButtonDeleteBatchLabel.setHidden(False)

        self.ui.lineEditTargetLabel.setEnabled(True)

        self.ui.lineEditTargetLabel.setHidden(False)

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        dataList = appDocData.getTrainingSymbolFileList()

        # for reset chart

        self.labelList = []

        for labelCounts in self.labelList:

            labelCount = [labelCounts[0], labelCounts[1]]

            self.labelList.append(labelCount)

        for data in dataList:

            if data.find('.xml') is not -1:

                labelPath = os.path.join(project.getTrainingSymbolFilePath(), data)

                xml = parse(labelPath)

                root = xml.getroot()

                objects = list(root.iter('object'))

                for object_node in objects:

                    name = object_node.find('name').text

                    matches = [_label for _label in self.labelList if _label[0] == name]

                    if matches:

                        matches[0][1] = matches[0][1] + 1

                    else:

                        self.labelList.append([name, 1])

        self.makeChart()

    '''

        @brief      close dialog by button click

        @author     euisung

        @date       2018.10.18

    '''

    def pushButtonCloseClicked(self):

        QDialog.reject(self)

    '''

        @brief      update image list

        @author     euisung

        @date       2018.10.18

    '''

    def listUpdate(self):

        appDocData = AppDocData.instance()

        project = appDocData.getCurrentProject()

        dataList = appDocData.getTrainingSymbolFileList()

        imgCount = 0

        for data in dataList:

            if data.find('.png') is not -1:

                imgCount += 1

        self.ui.tableWidgetList.setRowCount(imgCount)

        row = 0

        for data in dataList:

            if data.find('.png') is not -1:

                self.ui.tableWidgetList.setItem(row, 0, QTableWidgetItem(str(row + 1)))

                self.ui.tableWidgetList.setItem(row, 1, QTableWidgetItem(data))

                allDataList = appDocData.getTrainingSymbolFileList()

                for adata in allDataList:

                    labelName = data.replace('.png', '.xml')

                    if adata.find(labelName) is not -1:

                        labelPath = os.path.join(project.getTrainingSymbolFilePath(), labelName)

                        modifiedTime = str(datetime.datetime.strptime(time.ctime(os.path.getmtime(labelPath)), "%a %b %d %H:%M:%S %Y"))

                        self.ui.tableWidgetList.setItem(row, 2, QTableWidgetItem(modifiedTime))

                        labels = []

                        xml = parse(labelPath)

                        root = xml.getroot()

                        objects = list(root.iter('object'))

                        for object_node in objects:

                            name = object_node.find('name').text

                            if name not in labels:

                                labels.append(name)

                        labelContent = QTableWidgetItem(','.join(labels))

                        labelContent.setFont(QFont('Consolas', 9, QFont.Bold))

                        self.ui.tableWidgetList.setItem(row, 3, QTableWidgetItem(labelContent))

                        break

                    else:

                        self.ui.tableWidgetList.setItem(row, 2, QTableWidgetItem(''))

                        self.ui.tableWidgetList.setItem(row, 3, QTableWidgetItem(''))

                row += 1

    '''

        @brief      delete training box only by button click

        @author     euisung

        @date       2018.10.18

    '''

    def pushButtonLabelDeleteClicked(self):

        try:

            row = self.ui.tableWidgetList.selectedIndexes()[0].row()

            col = self.ui.tableWidgetList.selectedIndexes()[0].column()

            drawingName = self.ui.tableWidgetList.item(row, 1).text()

            labelDate = self.ui.tableWidgetList.item(row, 2).text()

            if labelDate == '':

                return

        except Exception as ex:

            pass

        try:

            reply = QMessageBox.question(self, self.tr('Continue?'), self.tr('Are you sure you want to delete the label job? '), QMessageBox.Yes, QMessageBox.Cancel)

            if reply == QMessageBox.Yes:

                appDocData = AppDocData.instance()

                project = appDocData.getCurrentProject()

                drawingPath = os.path.join(project.getTrainingSymbolFilePath(), drawingName)

                labelName = drawingPath.replace('.png', '.xml')

                if os.path.isfile(labelName):

                    os.remove(labelName)

                self.ui.tableWidgetList.item(row, 2).setText('')

                self.ui.tableWidgetList.item(row, 3).setText('')

                #self.listUpdate()

        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      delete training image and box by button click

        @author     euisung

        @date       2018.10.18

    '''

    def pushButtonImageDeleteClicked(self):

        try:

            row = self.ui.tableWidgetList.selectedIndexes()[0].row()

            col = self.ui.tableWidgetList.selectedIndexes()[0].column()

            drawingName = self.ui.tableWidgetList.item(row, 1).text()

        except Exception as ex:

            pass

        try:

            reply = QMessageBox.question(self, self.tr('Continue?'), self.tr('Are you sure you want to delete selected image? '), QMessageBox.Yes, QMessageBox.Cancel)

            if reply == QMessageBox.Yes:

                appDocData = AppDocData.instance()

                project = appDocData.getCurrentProject()

                drawingPath = os.path.join(project.getTrainingSymbolFilePath(), drawingName)

                if os.path.isfile(drawingPath):

                    os.remove(drawingPath)

                labelName = drawingPath.replace('.png', '.xml')

                if os.path.isfile(labelName):

                    os.remove(labelName)

                self.ui.tableWidgetList.removeRow(row)

                #self.listUpdate()

        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      make training data by button click

        @author     euisung

        @date       2018.10.17

    '''

    def makeTrainingImageClicked(self):

        from PIL import Image

        import math, uuid

        from random import shuffle

        try:

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            tilePath = os.path.join(project.getTempPath(), 'tile')

            rootList = os.listdir(tilePath)

            self.ui.progressBar.setValue(0)

            self.ui.progressBar.setMaximum(len(rootList))

            maxsize = self.ui.spinBox_2.value()

            for root in rootList:

                images = []

                rootPath = os.path.join(tilePath, root)

                imgList = os.listdir(rootPath)

                for img in imgList:

                    imgPath = os.path.join(rootPath, img)

                    img = Image.open(imgPath)

                    images.append([img, imgPath])

                grid_size = [None, None]

                for img in images:

                    if grid_size[0] is None or grid_size[0] < img[0].size[0]:

                        grid_size[0] = img[0].size[0]

                    if grid_size[1] is None or grid_size[1] < img[0].size[1]:

                        grid_size[1] = img[0].size[1]

                space = 5

                grid_size[0] = grid_size[0] + space * 2

                grid_size[1] = grid_size[1] + space * 2

                dimension = [None, None]

                dimension[0] = int(maxsize / grid_size[0])

                dimension[1] = int(maxsize / grid_size[1])

                pages = int(len(images) / (dimension[0] * dimension[1])) + 1

                for page in range(pages):

                    merged_img = Image.new("RGB", (maxsize, maxsize), (256,256,256))

                    done = False

                    for j in range(dimension[1]):

                        for i in range(dimension[0]):

                            index = (page * dimension[0] * dimension[1]) + j * dimension[0] + i

                            if index >= len(images):

                                done = True

                                break

                            loc = [i*(grid_size[0]), j*(grid_size[1])]

                            label_image = images[index][0]

                            x = loc[0] + space

                            y = loc[1] + space

                            merged_img.paste(label_image, (x, y, x + label_image.width, y + label_image.height))

                        if done: break

                    train_image_path = os.path.join(project.getTrainingSymbolFilePath(), str(uuid.uuid4()) + '.png')

                    merged_img.save(train_image_path)

        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)

            return None

        try:

            QMessageBox.about(self, self.tr("Notice"), self.tr('Successfully applied. '))

        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)

    def makeChart(self):

        '''

            @brief      make chart for trained charaters

            @author     euisung

            @date       2018.11.19

        '''

        try:

            barList = []

            categories = []

            for char in self.labelList:

                categories.append(char[0])

                barList.append(char[1])

            categoriesDict = [list(zip(range(len(categories)), categories))]

            if not hasattr(self, '_winChart'):

                self._winChart = pg.PlotWidget(background = 'w', title = 'Trained Symbols')

                self._winChart.setMouseEnabled(False, False)

                self._plot = pg.BarGraphItem(x = range(len(categories)), height = barList, width = 0.6, brush = 'b')

                self._winChart.addItem(self._plot)

                xax = self._winChart.getAxis('bottom')

                yax = self._winChart.getAxis('left')

                xax.setPen('k')

                yax.setPen('k')

                xax.setTicks(categoriesDict)

                self._winChart.showGrid(x = True, y = True)

                self.ui.horizontalLayoutChart.addWidget(self._winChart)

            else:

                self._winChart.removeItem(self._plot)

                self._plot = pg.BarGraphItem(x = range(len(categories)), height = barList, width = 0.6, brush = 'b')

                self._winChart.addItem(self._plot)

                xax = self._winChart.getAxis('bottom')

                yax = self._winChart.getAxis('left')

                xax.setPen('k')

                yax.setPen('k')

                xax.setTicks(categoriesDict)

                self._winChart.showGrid(x = True, y = True)

        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      make Box data by button click

        @author     euisung

        @date       2018.10.16

    '''

    def pushButtonLabelClicked(self):

        from PIL import Image

        try:

            row = self.ui.tableWidgetList.selectedIndexes()[0].row()

            col = self.ui.tableWidgetList.selectedIndexes()[0].column()

            drawingName = self.ui.tableWidgetList.item(row, 1).text()

        except:

            return

        try:

            appDocData = AppDocData.instance()

            project = appDocData.getCurrentProject()

            drawingPath = os.path.join(project.getTrainingSymbolFilePath(), drawingName)

            drawing = Image.open(drawingPath)

            labelName = drawingName.replace('.png', '.boxS')

            dataList = appDocData.getTrainingSymbolFileList()

            isBoxFile = False

            for data in dataList:

                if data.find(labelName) is not -1:

                    isBoxFile = True

            traininglabelPath = os.path.join(project.getTrainingSymbolFilePath(), labelName)

            boundaryOcrData = None

            if not isBoxFile:

                docData = AppDocData.instance()

                ### make contour

        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)

        try:

            dialog = QTrainingSymbolEditorDialog(self, drawingPath, traininglabelPath, boundaryOcrData, self.ui.tableWidgetList.item(row, 2), self.ui.tableWidgetList.item(row, 3))

            dialog.exec_()

        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)

        return

    '''

        @brief      add drawing to Selected by button click

        @author     euisung

        @date       2018.09.28

    '''        

    def addListClicked(self):

        try:

            row = self.ui.tableWidgetList.selectedIndexes()[0].row()

            col = self.ui.tableWidgetList.selectedIndexes()[0].column()

            self.listCellDoubleClicked(row, col)

        except Exception as ex:

            pass

    '''

        @brief      delete character in box data as batch

        @author     euisung

        @date       2019.02.22

    ''' 

    def pushButtonDeleteBatchLabelClicked(self):

        try:

            targetChar = self.ui.lineEditTargetLabel.text()

            if targetChar == '':

                return

            reply = QMessageBox.question(self, self.tr('Continue?'), self.tr('Are you sure you want to delete character "{}" in all box data?\nData can not be restored! '.format(targetChar)), QMessageBox.Yes, QMessageBox.Cancel)

            if reply == QMessageBox.Yes:

                appDocData = AppDocData.instance()

                project = appDocData.getCurrentProject()

                drawingPath = project.getTrainingSymbolFilePath()

                boxList = os.listdir(drawingPath)

                nonBoxList = []

                for index in range(len(boxList)):

                    if boxList[index][-4:] != 'boxS':

                        nonBoxList.append(index)

                nonBoxList.sort(reverse=True)

                for index in nonBoxList:

                    boxList.pop(index)

                for box in boxList:

                    labelPath = os.path.join(drawingPath, box)

                    fw = open(labelPath, 'r', encoding='utf8')

                    labelContent = fw.read()

                    fw.close()

                    labelContent = labelContent.split('\n')[:-1]

                    newlabelContent = []

                    for boxString in labelContent:

                        if boxString[0] != targetChar:

                            newlabelContent.append(boxString)

                    outBox = ''

                    for boxString in newlabelContent:

                        outBox += boxString + '\n'

                    fw = open(labelPath, 'w', encoding='utf8')

                    fw.write(outBox)

                    fw.close()

                #self.listUpdate()

            self.ui.lineEditTargetLabel.setText('')

        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      make Box data by cell double click

        @author     euisung

        @date       2018.09.28

    '''

    def listCellDoubleClicked(self, row, col):

        self.pushButtonLabelClicked()

    '''

        @brief      key pressed event

        @author     euisung

        @date       2018.11.05

    '''

    def keyPressEvent(self, event):

        try:

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

                try:

                    col = self.ui.tableWidgetList.selectedIndexes()[0].column()

                    if col == 1:

                        self.pushButtonImageDeleteClicked()

                    elif col == 2:

                        self.pushButtonLabelDeleteClicked()

                except Exception as ex:

                    pass

            QDialog.keyPressEvent(self, event)

        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)

            return None

        self.lineEditTargetLabel = QtWidgets.QLineEdit(TraingingSymbolImageListDialog)

        self.lineEditTargetLabel.setMaximumSize(QtCore.QSize(200, 16777215))

        self.lineEditTargetLabel.setMaxLength(50)

        self.lineEditTargetLabel.setObjectName("lineEditTargetLabel")

        self.horizontalLayout_4.addWidget(self.lineEditTargetLabel)

    <addaction name="separator"/>

    <addaction name="actionSymbol_Training"/>

  <action name="actionSymbol_Training">

   <property name="text">

    <string>Symbol Training</string>

   </property>

  </action>

      <widget class="QLineEdit" name="lineEditTargetLabel">

         <width>200</width>

        <number>50</number>

         <weight>75</weight>

         <bold>true</bold>