a

import pandas as pd
from numpy import ndarray
from sklearn import preprocessing
from sklearn.neighbors import KNeighborsClassifier
from scipy import stats
from sklearn.naive_bayes import GaussianNB
import statistics
from sklearn.metrics import pairwise_distances_argmin_min
import numpy as np
from random import randint
import matplotlib.pyplot as plt
import cv2
from sklearn.decomposition import PCA
import glob
from sklearn.metrics import pairwise_distances_argmin_min
from sklearn.metrics import accuracy_score
from operator import itemgetter
import math
import os

# Carregando fotos da pasta
def loadFiles(path, array):

    for i in glob.glob(path):

        img = cv2.imread(i)
        array.append(img)

    return array

# Função que faz o filtro cinza nas fotos
def grayConversion(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = cv2.cvtColor(arrayphotos[x], cv2.COLOR_BGR2GRAY)

    return arrayphotos

# Função que aplic o filtro blur nas fotos do array
def blurConversion(arrayphotos ,val1, val2):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.GaussianBlur(arrayphotos[x],(val1,val1), val2)

    return arrayphotos

#Função que faz a binarização das fotos
def binaryConversion(arrayphotos,threshold,val1):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.adaptiveThreshold(arrayphotos[x],threshold,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,val1,10)

    return arrayphotos

#Função que inverte as fotos binárias
def invertConversion(arrayphotos):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.bitwise_not(arrayphotos[x])

    return arrayphotos


# função de normalização dos dados usando o modelo de
# normalização por reescala

def normalizar(dados):
    x = dados.values
    min_max_scaler = preprocessing.MinMaxScaler()
    x_scaled = min_max_scaler.fit_transform(x)
    dados_norm = pd.DataFrame(x_scaled)
    return dados_norm


def geneticlabels(dataframe,centers):
    return pairwise_distances_argmin_min(dataframe,centers,metric='minkowski')

def find_clusters(X, n_clusters, rng, max_it):

    i = rng.permutation(X.shape[0])[:n_clusters]
    centers = X[i]

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances

def accuracy_majority_vote(base, predict_labels, real_labels, n_clusters):

    classes = real_labels.unique()

    majority = []
    groups = []
    k = 0
    for i in range(n_clusters):
        group = []
        for a in range(len(base)):
            if predict_labels[a] == i:
                group.append(real_labels[a])
        groups.append(group)
        majority.append(initialize_dic_majority(classes))
        for real_label in group:
            majority[k][real_label] += 1
        k += 1

    label_groups = []
    for m in majority:
        label_groups.append(max(m.items(), key=itemgetter(1))[0])

    pred_labels = []
    true_labels = []
    for g in range(len(groups)):
        pred_labels = pred_labels + ([label_groups[g]]*len(groups[g]))
        true_labels = true_labels + [a for a in groups[g]]

    return accuracy_score(pred_labels, true_labels)


def find_clustersGENETIC(X, n_clusters, max_it, array):

    centers = array

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances


def WCSSgenetic(x, population):

    arrayint = []
    for a in x:
        arrayint.append(int(a))

    print(arrayint)
    soma = 0
    for b in arrayint:
        labels, distances = pairwise_distances_argmin_min(population[b],population, metric='minkowski')
        for x in distances:
            soma += x**2
    return soma


def generatepopulation(X,numberpopu, K, rng):

    population = []

    for x in range(numberpopu):
        first = rng.permutation(X.shape[0])[:K]
        print(first)
        population.append(np.concatenate(X[first]))

    return population


def find_clustersgenetic(X, n_clusters, max_it, array):

    centers = array

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])

        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances


#FUNÇÃO DE NORMALIZAÇÃO

def imgtoarray(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = np.array(arrayphotos[x] , dtype=float)

    return arrayphotos

def gethumoments(arrayphotos):

    for x in range(len(arrayphotos)):

        arrayphotos[x] = cv2.HuMoments(cv2.moments(arrayphotos[x]), True).flatten()

    return arrayphotos

def WCSS2(distance):
    soma = 0
    for x in distance:
        soma += x ** 2

    return soma


def initialize_dic_majority(classes):
    majority = {}
    for c in classes:
        majority[c] = 0

    return majority


def extratorCaracteristicas(arrayimgs):

    squarescarac = []


    for x in arrayimgs:

        aux = []

        im2, countours, hierachy = cv2.findContours(x, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        if len(countours) == 0:

            for b in range(0,45):

                aux.append(0)

        elif len(countours) > 0:

            momentum = cv2.moments(x)
            momentum = list(dict.values(momentum))  # momentos
            for i in momentum:
                aux.append(i)

            moments = cv2.HuMoments(momentum, True).flatten()  # Hu moments

            for i in moments:
                aux.append(i)

            area = cv2.contourArea(countours[0])  # area
            aux.append(area)

            peri = cv2.arcLength(countours[0], True)  # perimetro
            aux.append(peri)

            if peri > 0:
                compactness = (4 * math.pi * area) / (peri ** 2)  # compacidade
                aux.append(compactness)
            elif peri == 0:
                aux.append(0)

            aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True)  # vertices
            vertc = len(aproxx)
            aux.append(vertc)

            histogram = get_histogram(aproxx)  # Frequencia de angulos

            for h in histogram:
                aux.append(h)

        squarescarac.append(aux)


    return squarescarac

def niveisCinza(image):

    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)

    return gray


def filtroGaussiano(image):

    gaussianb = cv2.GaussianBlur(image,(5,5),0)

    return gaussianb

def turnToBinary(image):

    binary = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,31,10)

    return binary

def inverterCores(image):

    invert = cv2.bitwise_not(image)

    return invert

def resizeImages(images,width,height):

    i = len(images)
    for x in range(0,i):

        images[x] = cv2.resize(images[x],(width,height))

    return images


def angle3pt(a, b, c):
    """Counterclockwise angle in degrees by turning from a to c around b
        Returns a float between 0.0 and 360.0"""
    ang = math.degrees(
        math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0]))

    return ang + 360 if ang < 0 else ang

def get_vertices(imagem):

    im2, countours, hierachy = cv2.findContours(imagem, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    peri = cv2.arcLength(countours[0], True)  # perimetro

    aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True)  # vertices

    return aproxx

def get_angle(p0, p1, p2):

    v0 = np.array(p0) - np.array(p1)
    v1 = np.array(p2) - np.array(p1)

    angle = np.math.atan2(np.linalg.det([v0, v1]), np.dot(v0, v1))
    return np.degrees(angle)


def get_histogram(aproxx):
    zero = []
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    #transformando em um array bidimensional
    retornopollyDP = np.reshape(aproxx, (aproxx.shape[0], (aproxx.shape[1] * aproxx.shape[2])))

    #checando se não é uma linha
    if (len(retornopollyDP) < 3):

        return zero

    arraysdeangulo = []

    for x in range(len(retornopollyDP)):
        # caso especial : quando a primeira posição do array for o angulo central
        if x == 0:

            bla3 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[len(retornopollyDP) - 1])
            arraysdeangulo.append(math.fabs(bla3))

        # caso especial : quando a última posição do array for o ângulo central
        if x == len(retornopollyDP) - 1:

            bla4 = get_angle(retornopollyDP[x - 1], retornopollyDP[x], retornopollyDP[0])
            arraysdeangulo.append(math.fabs(bla4))

        if x > 0 and x < len(retornopollyDP) - 1:

            bla5 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[x - 1])
            arraysdeangulo.append(math.fabs(bla5))

    hist, bins = np.histogram(arraysdeangulo, bins=[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180])

    return hist


# função que calcula os valores de média, moda , mediana e desvio padrão
# para os vetores de acerto de um algoritmo, recebe como parâmetro o vetor
# de acerto e o nome do algoritmo

def tendencia_central (nomeAlgoritmo, vetorAcerto, vetorTempo):
    print('________________________________________________\n')
    print(nomeAlgoritmo)
    print('Tempo Média = ', np.mean(vetorTempo))
    print('Tempo Desvio padrão = ', statistics.pstdev(vetorTempo))
    print('Tempo Moda = ', stats.mode(vetorTempo, axis=None))
    print('Tempo Mediana =', np.median(vetorTempo))
    print('----------------------------------------------')
    print('Acurácia Média = ', np.mean(vetorAcerto))
    print('Acurácia Desvio padrão = ', statistics.pstdev(vetorAcerto))
    print('Acurácia Moda = ', stats.mode(vetorAcerto, axis=None))
    print('Acurácia Mediana = ', np.median(vetorAcerto))

    print('________________________________________________\n')

# funcão que seleciona num quantidade de imagens aleatoriamente
# em um vetor e retorna um vetor auxiliar apenas com as imagens
# selecionadas


def seleciona_imagens (arrayImgs, num):
    tamanho = len(arrayImgs)
    selecionadas = []
    nao_selecionadas = []
    aux = []
    var = 0

    for x in range(0, num):

        if x == 0:

            var = randint(0, tamanho - 1)
            aux.append(var)
            selecionadas.append(arrayImgs[var])

        elif x > 0:

            var = randint(0, tamanho - 1)

            while np.isin(var ,aux):

                var = randint(0, tamanho - 1)

            selecionadas.append(arrayImgs[var])
            aux.append(var)

    for x in range(0, tamanho):
        if np.isin(x,aux):
            continue
        else:
            nao_selecionadas.append(arrayImgs[x])

    return selecionadas, nao_selecionadas


def is_similar(image1, image2):

    retorno = image1.shape == image2.shape and not(np.bitwise_xor(image1,image2).any())

    return retorno


def create_folder(path):
    x = 0
    try:
        os.mkdir(path)
    except OSError:
       x = -1
    else:
        x = 1
    return x


def save_images(images, path):
    cont = 0

    for i in images:
        y = str(cont)
        cv2.imwrite(path + y + '.jpg', i)
        cont += 1

    return 0

# checa se o elemento escolhido já existe no array aux para
# evitar elementos duplicados

# var = randint(0, tamanho)
#
# for i in range(0, len(aux)):
#     if is_similar(arrayImgs[var], aux[i]):
#         duplicate = 1
#
# while duplicate == 1:


def delete_folder (path):
    x = 0
    try:
        os.rmdir(path)
    except OSError:
        x = -1
    else:
        x = 1
    return x

def create_population(size_population, size_chromossome):
    population = []

    for y in range(0, size_population):
        aux = []
        for i in range(0, size_chromossome):
            x = randint(0, 200)
            if x % 2 == 0:
                aux.append(0)
            elif x % 2 != 0:
                aux.append(1)
        population.append(aux)

    return population

def decode_chromossome(chromossome):
    selected_carac = []
    selected_carac = pd.DataFrame(selected_carac)
    aux = []
    images = []
    if chromossome[0] == 0 and chromossome[1] == 0:
        images = loadFiles('C:/Users/Auricelia/Desktop/DataSetsML/Images_16_s.csv',images)
    elif chromossome[0] == 0 and chromossome[1] == 1:
        images = loadFiles('C:/Users/Auricelia/Desktop/DataSetsML/Images_32_s.csv',images)
    elif chromossome[0] == 1 and chromossome[1] == 0:
        images = loadFiles('C:/Users/Auricelia/Desktop/DataSetsML/Images_64_s.csv',images)
    elif chromossome[0] == 1 and chromossome[1] == 1:
        images = loadFiles('C:/Users/Auricelia/Desktop/DataSetsML/Images_128_s.csv',images)

    for c in range(2,len(chromossome)):
        if chromossome[c] == 1:
            selected_carac[]
        elif chromossome[c] == 0:
            continue