ubuwidgets.py

from PyQt5.QtCore import Qt, QDir, QFile, QPoint, QRect, QSize
from PyQt5.QtWidgets import QWidget, QPushButton, QLineEdit, QLabel, QGridLayout
from PyQt5.QtGui import QImage, QImageWriter, QPainter, QPen, qRgb, QPixmap

import os
#import matplotlib.pyplot as plt

# Import datasets, classifiers and performance metrics
from sklearn import datasets, svm, metrics
from PIL import Image
import numpy as np
import math
from sklearn.metrics import accuracy_score
from sklearn.externals import joblib

class Button(QWidget):
    def __init__(self,parent=None, label="Button", on_click=None):
        super(Button,self).__init__(parent)
        button = QPushButton(label, self)
        button.move(220,0)
        button.clicked.connect(on_click)
        grid = QGridLayout()
        grid.addWidget(button,1,0,1,2)
        self.setLayout(grid) 
        
class ComboWidget(QWidget):
    def __init__(self, parent=None, 
                 text_on_label="Label", 
                 text_on_button="button", 
                 on_click=None, readOnly=False):
        super(ComboWidget,self).__init__(parent)

        button = QPushButton(text_on_button, self)
        lbl = QLabel(self)
        lbl.setText(text_on_label)
        self.qle = QLineEdit(self)
        self.qle.setReadOnly(readOnly)
        self.qle.setAlignment(Qt.AlignCenter)
        button.clicked.connect(on_click)
        grid = QGridLayout()
        grid.addWidget(lbl,1,0)
        grid.addWidget(self.qle,1,1)
        grid.addWidget(button,1,2)
        self.setLayout(grid) 
    
    def text(self):
        return self.qle.text()
    
    def set_text(self, text=""):
        self.qle.setText(text)
    
class Board(QWidget):
    def __init__(self,parent=None):
        super(Board,self).__init__(parent)
        self.setAttribute(Qt.WA_StaticContents)
        self.penWidth = 50
        self.writing = False
        self.penColor = Qt.black
        self.image = QImage()
        self.lastPoint = QPoint()
        self.setFixedSize(512,512)

    def saveImage(self,label):
        import os
        visibleImage = self.image
        self.resizeImage(visibleImage,self.size())
        if QDir('Image').exists() == False:
            QDir().mkdir('Image')

        label = 'Image/'+label
        if QDir(label).exists() == False:
            QDir().mkdir(label)
        cnt = 0
        maxf = 0
        for file in os.listdir(label):
            if file.endswith('.png'):
                cnt += 1
                tmpN = int(file[:-4:])
                maxf = max(maxf,tmpN)
        visibleImage.save('tmp.png')
        pixmap = QPixmap('tmp.png').scaled(64,64)
        pixmap.save(label+'/'+str(max(cnt,maxf)+1)+'.png')
        QFile.remove('tmp.png')
        
    def saveImageTest(self):
        import os
        visibleImage = self.image
        self.resizeImage(visibleImage,self.size())
        if QDir('Test').exists() == False:
            QDir().mkdir('Test')

        visibleImage.save('tmp.png')
        pixmap = QPixmap('tmp.png').scaled(64,64)
        pixmap.save('Test/temp.png')
        QFile.remove('tmp.png')

    def paintEvent(self, event):
        painter = QPainter(self)
        dirtyRect = event.rect()
        painter.drawImage(dirtyRect, self.image, dirtyRect)

    def clearImage(self):
        self.image.fill(qRgb(255,255,255))
        self.update()

    def mousePressEvent(self,event):
        if event.button() == Qt.LeftButton:
            self.lastPoint = event.pos()
            self.writing = True

    def mouseMoveEvent(self,event):
        if (event.buttons() & Qt.LeftButton) and self.writing:
            self.drawLineTo(event.pos())

    def mouseReleaseEvent(self,event):
        if event.button() == Qt.LeftButton and self.writing:
            self.drawLineTo(event.pos())
            self.writing = False

    def resizeEvent(self,event):
        self.resizeImage(self.image,self.size())
        self.update()
        super(Board,self).resizeEvent(event)
    
    def drawLineTo(self, endPoint):
        painter = QPainter(self.image)
        painter.setPen(QPen(self.penColor, self.penWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
        painter.drawLine(self.lastPoint, endPoint)
        self.writing = True

        rad = self.penWidth/2 + 2
        self.update(QRect(self.lastPoint, endPoint).normalized().adjusted(-rad, -rad, +rad, +rad))
        self.lastPoint = QPoint(endPoint)

    def resizeImage(self,image, newSize):
        if image.size() == newSize:
            return
        newImage = QImage(newSize, QImage.Format_RGB32)
        newImage.fill(qRgb(255,255,255))
        painter = QPainter(newImage)
        painter.drawImage(QPoint(0,0), image)
        self.image = newImage

    def data_prep_test(self):   
        self.saveImageTest()
        im = Image.open('Test/temp.png')
        iar = np.array(im)
        
        width, height = im.size
        test_data = np.zeros(width*height)
        
        test_data = np.zeros(64*64)
        count = 0
        for i in range(len(iar)):
            for j in range(len(iar[i])):
                test_data[count] = math.floor(((np.sum(iar[i][j][:3]/765))))
                #print(test_data[count])
                count+=1
        return [test_data]  

    def data_prep_train(self):
        print('preporcessing..')
        folder_name = 'Image/'
        list_of_label = os.listdir(folder_name)
        digit_data = list()
        digit_label = list()
        for label in list_of_label:
            label_path = folder_name+str(label)+'/'
            list_of_data = os.listdir(label_path)
           #print(list_of_data)
            for data in list_of_data:
                im = Image.open(label_path+'/'+data)
                arr_im = np.array(im)
                width, height = im.size
                gen_data = np.zeros(width*height)
                count = 0
                for i in range(len(arr_im)):
                    for j in range(len(arr_im[i])):
                        #ทำ Normalize ด้วยการ (R+G+B) หาร 765 มาจาก (255+255+255)
                        gen_data[count] = math.floor(((np.sum(arr_im[i][j][:3]/765))))
                        count+=1
                digit_data.append( gen_data )
                digit_label.append( label )     
        digit_data = np.array(digit_data)  #ข้อมูล
        digit_label = np.array(digit_label) # label ของข้อมูล  
        return digit_data,digit_label         
    
    
    def evaluation(self, digit_data, digit_label, classifier):
        predicted = classifier.predict(digit_data)
        print("Classification report for classifier %s:\n%s\n"
              % (classifier, metrics.classification_report(digit_label, predicted)))
        print("Confusion matrix:\n%s" % metrics.confusion_matrix(digit_label, predicted))
        print("\naccuracy = ",accuracy_score(digit_label, predicted))