from sklearn import tree
from sklearn.preprocessing import LabelEncoder
# import pandas as pd
# import numpy as np
from sklearn import cluster
from sklearn import datasets
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import matplotlib.pyplot as plt
import cv2

from sklearn import datasets, svm, metrics
digits = datasets.load_digits()
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis

def zadanie1():
    # przebieg = [100000, 67000, 45879, 300002]
    # marka = ['audi', 'mercedes', 'porshe', 'opel']
    # uszkodzony = [1, 0, 0, 0]

    X = [[100000, 1, 1],
         [6700, 2, 1],
         [45879, 3, 0],
         [300002, 4, 0]]
         # [100000, 67000, 45879, 300002],
         # ['audi', 'mercedes', 'porshe', 'opel'],
         # [1, 0, 0, 0]]
    Y = [1, 1, 0, 0]

    # print(X[:,1])
    # le = LabelEncoder()
    # X[:,1] = le.fit_transform(X[:,1])
    # print(X[:,1])
    # X = pd.DataFrames(X)


    drzewko = tree.DecisionTreeClassifier()
    drzewko = drzewko.fit(X, Y)
    pred = drzewko.predict([[200000, 1, 0]])
    print(pred)

def zadanie2():
    pora = {'rano': 0, 'poludnie': 1, 'wieczor': 2, 'noc': 3}

    X = [[15, pora['rano'], 0],
         [7, pora['noc'], 1],
         [23, pora['poludnie'], 0],
         [14, pora['noc'], 1],
         [19, pora['wieczor'], 1]]
    Y = [1, 0, 1, 0, 1]

    drzewko = tree.DecisionTreeClassifier()
    drzewko = drzewko.fit(X, Y)
    pred = drzewko.predict([[17, pora['wieczor'], 1]])
    print(pred)


def zadanie3():
    iris = datasets.load_iris()
    print(iris.data)
    print(iris.target)

    X = iris.data
    k_means = cluster.KMeans(n_clusters=3)
    k_means.fit(X)

    labels = k_means.labels_
    fig = plt.figure()
    ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)
    ax.scatter(X[:, 3], X[:, 0], X[:, 2], c=labels.astype(np.float))
    ax.w_xaxis.set_ticklabels([])
    ax.w_yaxis.set_ticklabels([])
    ax.w_zaxis.set_ticklabels([])
    ax.set_xlabel('Petal width')
    ax.set_ylabel('Sepal length')
    ax.set_zlabel('Petal length')
    plt.show()


def zadanie4():
    lista_plaz = []
    lista_lasow = []
    X = []
    for x in range(1, 11):
        nazwa_plaza = 'beach' + np.str(x) + '.jpg'
        nazwa_las = 'las' + np.str(x) + '.jpg'
        lista_plaz.append(cv2.imread(nazwa_plaza, cv2.IMREAD_COLOR))
        lista_lasow.append(cv2.imread(nazwa_las, cv2.IMREAD_COLOR))
        hist_plaz = cv2.calcHist(lista_plaz[x-1], [3], None, [8], [0, 256])
        hist_lasow = cv2.calcHist(lista_lasow[x-1], [3], None, [8], [0, 256])
        X.append(hist_plaz)
        X.append(hist_lasow)

    print(len(X))
    print(X)
    k_means = cluster.KMeans(n_clusters=2)
    k_means.fit(X)

    test_plaza = cv2.imread('test_plaza.jpg', cv2.IMREAD_COLOR)
    hist = cv2.calcHist(test_plaza, [3], None, [8], [0, 256])

    pred = k_means.predict(hist)
    print(pred)


def zadanie5():
    names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Gaussian Process",
             "Decision Tree", "Random Forest", "Neural Net", "AdaBoost",
             "Naive Bayes", "QDA"]

    classifiers = [
        KNeighborsClassifier(3),
        SVC(kernel="linear", C=0.025),
        SVC(gamma=2, C=1),
        GaussianProcessClassifier(1.0 * RBF(1.0)),
        DecisionTreeClassifier(max_depth=5),
        RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
        MLPClassifier(alpha=1),
        AdaBoostClassifier(),
        GaussianNB(),
        QuadraticDiscriminantAnalysis()]

    images_and_labels = list(zip(digits.images, digits.target))
    for index, (image, label) in enumerate(images_and_labels[:4]):
        plt.subplot(2, 4, index + 1)
        plt.axis('off')
        plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
        plt.title('Training: %i' % label)

    n_samples = len(digits.images)
    data = digits.images.reshape((n_samples, -1))

    classifier = svm.LinearSVC()
    classifier.fit(data[:np.int(n_samples / 2)], digits.target[:np.int(n_samples / 2)])
    expected = digits.target[np.int(n_samples / 2):]
    predicted = classifier.predict(data[np.int(n_samples / 2):])

    print("Classification report for classifier %s:\n%s\n"
          % (classifier, metrics.classification_report(expected, predicted)))
    print("Confusion matrix:\n%s" % metrics.confusion_matrix(expected, predicted))

    images_and_predictions = list(zip(digits.images[int(n_samples / 2):], predicted))
    for index, (image, prediction) in enumerate(images_and_predictions[:4]):
        plt.subplot(2, 4, index + 5)
        plt.axis('off')
        plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
        plt.title('Prediction: %i' % prediction)

    plt.show()


if __name__ == '__main__':#
    # zadanie1()
    # zadanie2()
    # zadanie3()
    # 4 PRAWIE DZIALA
    # zadanie4()
    zadanie5()