import cv2
import dlib
import numpy as np

from matplotlib import pyplot as plt

#from scipy.cluster.hierarchy import dendrogram, linkage, fcluster, fclusterdata, leaders

import scipy as sp
import time
import glob
import os

#propia
import utils
import vector_face as vecFace 
import clustering
import gender as gd

# Metode per clasificar per mitja del agrupament
def procesClassifiCluster(data,labels,args):
    
    #Es guarden els agrupaments ja definits per tipus dins el dict
    agrupacio = {} 
    agrupacio['images'] = []
    agrupacio['reps'] = []
    agrupacio['descarts'] = []
    agrupacio['desReps'] = []
    agrupacio['revImg'] = []
    agrupacio['revReps'] = []
    agrupacio['errors'] = []    
    
    
    # Filtre de histograma
    # Sortida [retornImg, retornReps, descarts, desReps]
    filtre = utils.filtreHist(images = labels, data = data, tall = 1000 , rangePos = [0,50] , equal=True, aviso=False)
    
    agrupacio['descarts'].extend(filtre[2])
    
    #Proba per comprovar les imatges que filtre
    utils.moveImg([agrupacio['descarts']],'./data/hist')
    
    temp = clustering.clustersJer(filtre[1],filtre[0], 1.2 , outDir = './data', metode = 'single', showDen = False, aviso = False, save = False) # agrupamiento Jerarquico
    
    #Proba per comprovar les imatges que filtre
    utils.moveImg(temp[4],'./data/llista')
    
    tImg = utils.unirLlista(temp[1])
    tImg.extend(utils.unirLlista(temp[3]))
    
    tReps =  utils.unirLlista(temp[0])
    tReps.extend(utils.unirLlista(temp[2]))
    
    agrupacio['descarts'].extend(temp[4][0])
    
    clusters = [[],[],[tReps],[tImg]]
    
    n, i = len(tImg), 0.0
    
    # Proba amb els vectors 0 a 1 Binari - Revisar No agrupa amb aquest metode averageOne
    #clusters = cluster.similituts(valores[1],valores[0], float(args.corte_view) ,aviso = args.aviso, save = True, metode = 'dot')
    
    metode =''
    while n > 40:
        if n > 60:
            metode, corte = 'median',0.6
        else:
            if metode != 'weighted':
                i = 0
            metode, corte = 'weighted',0.8
            
        clusters = clustering.clustersJer(clusters[2][0],clusters[3][0], corte = corte+i, outDir = './data',metode = metode, showDen = True, aviso = False, save = False) # agrupamiento Jerarquico
        
        # Imatges agrupades resultat final
        agrupacio['images'].extend(clusters[1]) #Es guarden els agrupaments ja definits
        agrupacio['reps'].extend(clusters[0])
        
        # Les imatges que ja no es procesaran
        agrupacio['descarts'].extend(clusters[4][0])
        
        n = len(clusters[3][0])
        i += 0.02
    
    # Optim utiltza similituts amb funcio propia
    #clusters = cluster.similituts(clusters[2][0],clusters[3][0], float(args.corte_view) ,aviso = args.aviso, save = False)
    #clusters = cluster.clustersJer(tReps,tImg, 1.2 , outDir = './data',metode = 'ward', showDen = True, aviso = False, save = False) # agrupamiento Jerarquico
    
    # Imatges agrupades resultat final
    #agrupacio.extend(clusters[1])
    #agrupRep.extend(clusters[0])
    #descarts.extend(clusters[4][0])
    
    #Funcio per separar els clusters amb valors y mes baixos
    clusters = clustering.clustersJer(clusters[2][0],clusters[3][0], 1.2 , outDir = './data',metode = args.metode, showDen = True, aviso = False, save = False) # agrupamiento Jerarquico
    
    # Imatges agrupades resultat final
    agrupacio['images'].extend(clusters[1])
    agrupacio['reps'].extend(clusters[0])
    agrupacio['descarts'].extend(clusters[3][0])
    agrupacio['descarts'].extend(clusters[4][0])
    
    # Funcio per seperar segons clusters que dona el deontograma
    #clusters = cluster.clustersJer(valores[1],valores[0], float(args.corte_view), outDir = './data',metode = 'ward', showDen = False, aviso = False, save = False) # agrupamiento Jerarquico
    #clusters = cluster.clustersJer(clusters[2][0],clusters[3][0], float(args.corte_view), outDir = './data',metode = args.metode, showDen = True, aviso = True, save = True) # agrupamiento Jerarquico
    
    if args.aviso:
        print ""
        print " Organitzant Imatge(s) per la seva classificacio"
        print " Parametres: Metode d'organitacio: " + args.metode + " Valor de Tall " + str(args.corte_view)
        print "------------------------------------------------------------------------------"
    i,per = 0, -1
    n = len(clusters[0]) # Torna a calcular per dins dels clusters ja definits
    for cluster in clusters[0]:
        #resultat = cluster.jerarquico(cluster,clusters[1][i], 0.8, outDir = './data',metode = 'ward', showDen = True, aviso = False, save = True) # agrupamiento Jerarquico
        #agrupacio.extend(resultat[1])
        i += 1
        if args.aviso:
            if per < int((i/float(n))*100):
                per = int((i/float(n))*100)
                utils.progressBar(per)
    
    
    return agrupacio

# Proba per utilitzar la similitud amb binari
def procesSimil(data,labels,args):
    
     #Es guarden els agrupaments ja definits per tipus dins el dict
    agrupacio = {} 
    agrupacio['images'] = []
    agrupacio['reps'] = []
    agrupacio['descarts'] = []
    agrupacio['desReps'] = []
    agrupacio['revImg'] = []
    agrupacio['revReps'] = []
    agrupacio['errors'] = []    
    
    
    # Proba amb els vectors 0 a 1 Binari - Revisar No agrupa amb aquest metode averageOne
    # Sortida [reps,images,desReps,desImg]
    agrupacio['reps'], agrupacio['images'], agrupacio['desReps'], agrupacio['descarts'] = clustering.similituts(data = data, labels = labels, corte = float(args.corte_view) ,aviso = args.aviso, save = False, metode = 'averageOne')
    
    
    return agrupacio


def procesAverage(data,labels,args):
    
    #Es guarden els agrupaments ja definits per tipus dins el dict
    agrupacio = {} 
    agrupacio['images'] = []
    agrupacio['reps'] = []
    agrupacio['descarts'] = []
    agrupacio['desReps'] = []
    agrupacio['revImg'] = []
    agrupacio['revReps'] = []
    agrupacio['errors'] = []  
    
    
    # Filtre de histograma
    # Sortida [retornImg, retornReps, descarts, desReps]
    filtre = utils.filtreHist(images = labels, data = data, tall = 900 , rangePos = [0,100] , equal=True, aviso=False)
    
    agrupacio['descarts'].extend(filtre[2])
    
    #Proba per comprovar les imatges que filtre
    utils.moveImg([agrupacio['descarts']],'./data/hist')
    
    # sortida [reps,images,[revReps],[revImg],descart,valorsTall]
    temp = clustering.clustersJer(data = filtre[1],labels = filtre[0], corte = 1.2 , outDir = './data', metode = 'single', showDen = True, aviso = False, save = False) # agrupamiento Jerarquico
    
    #Proba per comprovar les imatges que filtre
    utils.moveImg([temp[4]],'./data/llista')
    
    
    tImg = utils.unirLlista(temp[1])
    tImg.extend(utils.unirLlista(temp[3]))
    
    tReps =  utils.unirLlista(temp[0])
    tReps.extend(utils.unirLlista(temp[2]))
    
    agrupacio['descarts'].extend(temp[4])
    
    clusters = [[],[],[tReps],[tImg]]
    
    #clusters = [[],[],[filtre[1]],[filtre[0]]]
    
    #clusters = [[],[],[data],[labels]]
    
    n, i = len(tImg[0]), 0.0
    
    metode ='average'
    while float(args.corte_view)+i < 0.901:
        
        # Sortida [reps,images,[revReps],[revImg],descart,valorsTall]
        clusters = clustering.clustersJer(clusters[2][0],clusters[3][0], corte = float(args.corte_view)+i, outDir = './data',metode = metode, showDen = True, aviso = False, save = True) # agrupamiento Jerarquico
        
        for vecs in clusters[0]:
            m = 1
            for vec in vecs:
                m = 0
                while m < len(vecs):
                    valor = vecFace.compareVectors(vec,vecs[m])
                    print 'Comparativa entre ' + str(valor)
                    m += 1
                
        
        # Imatges agrupades resultat final
        agrupacio['images'].extend(clusters[1]) #Es guarden els agrupaments ja definits
        agrupacio['reps'].extend(clusters[0])
        
        # Les imatges que ja no es procesaran
        agrupacio['descarts'].extend(clusters[4])
        
        agrupacio['revImg'] = clusters[3][0]
        agrupacio['revReps'] = clusters[2][0]
        
        n = len(clusters[3][0])
        i += 0.02
    
    # Comprovar els sitems de agrupacio per solitari
    # sortida [reps,images,[revReps],[revImg],descart,valorsTall]
    clusters = clustering.clustersJer(data = agrupacio['revReps'], labels = agrupacio['revImg'], corte = 1.0, outDir = './data',metode = 'weighted', showDen = True, aviso = False, save = True) # agrupamiento Jerarquico
    
    agrupacio['images'].extend(clusters[1]) #Es guarden els agrupaments ja definits
    agrupacio['reps'].extend(clusters[0])
    
    # Les imatges que ja no es procesaran
    agrupacio['descarts'].extend(clusters[4])
    
    agrupacio['revImg'] = clusters[3][0]
    agrupacio['revReps'] = clusters[2][0]
    
    # En cas de tenir un volum a comprovar de imatges per revisar
    while len(agrupacio['revImg']) > 6:
        
        clusters = clustering.clustersJer(data = agrupacio['revReps'], labels = agrupacio['revImg'], corte = 0.85, outDir = './data',metode = 'complete', showDen = True, aviso = False, save = True) # agrupamiento Jerarquico
        
        agrupacio['images'].extend(clusters[1]) #Es guarden els agrupaments ja definits
        agrupacio['reps'].extend(clusters[0])
        
        # Les imatges que ja no es procesaran
        agrupacio['descarts'].extend(clusters[4])
        
        agrupacio['revImg'] = clusters[3][0]
        agrupacio['revReps'] = clusters[2][0]
        
    if len(agrupacio['revImg']) > 1:
        
        clusters = clustering.clustersJer(data = agrupacio['revReps'], labels = agrupacio['revImg'], corte = 0.80, outDir = './data',metode = 'single', showDen = True, aviso = False, save = True) # agrupamiento Jerarquico
    
        agrupacio['images'].extend(clusters[1]) #Es guarden els agrupaments ja definits
        agrupacio['reps'].extend(clusters[0])
        
        # Les imatges que ja no es procesaran
        agrupacio['descarts'].extend(clusters[4])
        
        agrupacio['revImg'] = clusters[3][0]
        agrupacio['revReps'] = clusters[2][0]
        
    
    return agrupacio


# Proces de classificacio amb agrupament Jerarquic
def procesJerCom(data, labels, obj_images, args, mostrar = True):
     #Es guarden els agrupaments ja definits per tipus dins el dict
    agrupacio = {} 
    agrupacio['images'] = []
    agrupacio['reps'] = []
    agrupacio['obj_images'] = obj_images
    agrupacio['descarts'] = []
    agrupacio['desReps'] = []
    agrupacio['errors'] = []    
    
    tmp = {} #Dels vectors de cara
    tmpClothes = {} # dels vectors de roba
    
    # Filtre de histograma
    # Sortida [retornImg, retornReps, descarts, desReps]
    #filtre = utils.filtreHist(images = labels, data = data, tall = 91100 , rangePos = [0,10] , equal=True, aviso=False)
    
    #agrupacio['descarts'].extend(filtre[2])
    #agrupacio['desReps'].extend(filtre[3])
    
    #Proba per comprovar les imatges que filtre
    #utils.moveImg([agrupacio['descarts']],'./data/hist')
    
    #print 'Imatges a classificar :'
    #for im in filtre[0]:
    #    print 'Imatge --> ' + im
    
    #temp = [[],[],filtre[1],filtre[0]]
    temp = [[],[],data,labels] # per analitzar les dades descartades
       
    
    n, v = -1, 0
    m, me,ii = len(temp[3]), 0,0
    #metode = ('average','complete','median')
    #metode = ('average','complete')
    metode = args.metode.split(';')
    
    while (n != m) and (m > 0):
        if mostrar:
            print 
            print 'volta ' + str(v) + '  Metode ' + metode[me] + ' Tall ' + str(args.corte_jer)
            print '---------------------------------------------------------------------------------------------------'
        
        n = m
        
        # Resetejar on es guarden les organitzacions
        tmp['images'] = []
        tmp['reps'] = []
        tmp['obj_images'] = []
        tmpClothes['reps'] = []
        tmpClothes['images'] = []
        tmpClothes['clothes'] = []
        agrupacio['revImg'] = []
        agrupacio['revReps'] = []
        
        if args.corte_jer is None:
            # sortida [reps,images,revReps,revImg,descart,valorsTall]
            clusters = clustering.clustersJer(data = temp[2],labels = temp[3], corte = None, outDir = args.data_path, metode = metode[me], showDen = False, aviso = args.aviso, save = False) # agrupamiento Jerarquico Sense Tall
            
            agrupacio['descarts'].extend(clusters[4])            
        else:
            # sortida [reps,images]
            clusters = clustering.jerarquico(data = temp[2],labels = temp[3], corte = args.corte_jer, outDir = args.data_path, metode = metode[0], save = False , showDen=False, aviso = False) # Agrupament Jerarquic amb tall
            agrupacio['descarts'] = []
            
        i = 0
        # Es comprova si es vol utilitzar Pearson simplement saben si te valor 
        if args.corte_affinity is not None:
            for rev in clusters[0]:
                if len(rev) > 0:
                    # Sortida [outData,outLabels,decarts,desReps]
                    clust = revisarCluster(rev,clusters[1][i],tall = float(args.corte_affinity))
                    
                    if len(clust[1]) > 0:
                        tmp['images'].append(clust[1]) #Es guarden els agrupaments ja definits
                        tmp['reps'].append(clust[0])
                        #agrupacio['images'].append(clust[1]) #Es guarden els agrupaments ja definits
                        #agrupacio['reps'].append(clust[0])
                    
                    agrupacio['revImg'].extend(clust[2])
                    agrupacio['revReps'].extend(clust[3])
                i += 1
        else:
            for i in range(0,len(clusters[1])):
                if len(clusters[1][i]) > 0:
                    tmp['images'].append(clusters[1][i]) #Es guarden els agrupaments ja definits sense la revisio per Pearson
                    tmp['reps'].append(clusters[0][i])
        
        #Revisar la roba....
        #revisarClothes(data,labels, tall = 0.70, tallUp = 0.80, tallDown = 0.40, desDownMax = 0.20, desMax = 0.10,  diff = 0.015, mostrar = True):
        i = 0
        # Es comprova si es vol utilitzar bhattacharyya simplement saben si te valor 
        if args.corte_clothes is not None:
            tmp['obj_images'] = [[y  for y in obj_images for x in z  if y.getPath() == x] for z in tmp['images']]
            for rev in tmp['obj_images']:
                if len(rev) > 0:
                    # Sortida [outData,outLabels,decarts,desReps]
                    clust = revisarClothes(data = [x.getVecClothes() for x in rev], labels = [y.getPath() for y in rev], tall = float(args.corte_clothes))
                    
                    if len(clust[1]) > 0:
                        agrupacio['images'].append(clust[1]) #Es guarden els agrupaments ja definits
                        agrupacio['reps'].append([x.getVecFace() for x in rev if x.getPath() in clust[1]])
                    
                    agrupacio['revImg'].extend(clust[2])
                    agrupacio['revReps'].extend([x.getVecFace() for x in rev if x.getPath() in clust[2]])
                i += 1
        else:
            for i in range(0,len(tmp['images'])):
                if len(tmp['images'][i]) > 0:
                    agrupacio['images'].append(tmp['images'][i]) #Es guarden els agrupaments ja definits sense la revisio per Pearson
                    agrupacio['reps'].append(tmp['reps'][i])
        
        # Definir les noves imatges a revisar
        temp[2] = agrupacio['revReps']
        temp[3] = agrupacio['revImg']
        
        m = len(temp[3])
        v += 0.1 - ((0.02)*ii)
        #v += 1
        ii += 1
        me = [me+1 if int(me) < (int(len(metode))-1) else 0][0]
    
        
    if len(agrupacio['revImg']) > 0:
        agrupacio['descarts'].extend(agrupacio['revImg'])
        agrupacio['desReps'].extend(agrupacio['revReps'])
    
    return agrupacio



def procesAgrupament(data, labels, args , tipus ='meanshift', mostrar = True):
     #Es guarden els agrupaments ja definits per tipus dins el dict
    agrupacio = {} 
    agrupacio['images'] = []
    agrupacio['reps'] = []
    agrupacio['descarts'] = []
    agrupacio['desReps'] = []
    agrupacio['errors'] = []    
    
    #temp = [[],[],filtre[1],filtre[0]]
    temp = [[],[],data,labels]
    
    n, v = -1, 0
    m, me,ii = len(temp[3]), 0, 0
    
    while (n != m) and (m > 0):
        if mostrar:
            print 
            print 'volta ' + str(v) 
            print '---------------------------------------------------------------------------------------------------'
        
        n = m
        
        if not tipus in ['meanshift','spectral']:
            return None
        
        #Agrupacio per MeanShift o Spectral
        if tipus == 'meanshift':
            clusters = clustering.clusterMeanShift(data = temp[2], paths = temp[3])
        if tipus == 'spectral':
            clusters = clustering.clusterSpectral(data = temp[2], paths = temp[3], args = args)
        
        agrupacio['descarts'] = []
        agrupacio['revImg'] = []
        agrupacio['revReps'] = []
        
        i = 0
        # Es comprova si es vol utilitzar Pearson simplement saben si te valor 
        if args.corte_affinity is not None:
            for rev in clusters['reps']:
                if len(rev) > 0:
                    # Sortida [outData,outLabels,decarts,desReps]
                    clust = revisarCluster(rev,clusters['images'][i],tall = float(args.corte_affinity))
                    
                    if len(clust[1]) > 0:
                        agrupacio['images'].append(clust[1]) #Es guarden els agrupaments ja definits
                        agrupacio['reps'].append(clust[0])
                    
                    agrupacio['revImg'].extend(clust[2])
                    agrupacio['revReps'].extend(clust[3])
                
                i += 1
        else:
            for i in range(0,len(clusters['images'])):
                if len(clusters['images'][i]) > 0:
                    agrupacio['images'].append(clusters['images'][i]) #Es guarden els agrupaments ja definits sense la revisio per Pearson
                    agrupacio['reps'].append(clusters['reps'][i])
        
        temp[2] = agrupacio['revReps']
        temp[3] = agrupacio['revImg']
        
        m = len(temp[3])
        v += 1
        ii += 1
         
    if len(agrupacio['revImg']) > 0:
        agrupacio['descarts'].extend(agrupacio['revImg'])
        agrupacio['desReps'].extend(agrupacio['revReps'])
        
    return agrupacio

# funcio per comprovar que un cluster te les imatges similars
def revisarCluster(data,labels, tall = 0.70, tallUp = 0.80, tallDown = 0.40, desDownMax = 0.20, desMax = 0.10,  diff = 0.015, mostrar = True):
    descarts, desReps =[],[]
    outData, outLabels = data, labels

    if len(labels) > 2:
        
        n = len(data) 
        
        remove = []

        matValor = np.zeros((n,n))
        vecImg = [0 for x in range(0,n)]
        acum = 0.0
        nm = (n*(n-1))/2
        minim = float('Inf')
        maxim = float('-Inf')

        valor = 0.0
        for x in range(1,n):
            for y in range(0,x):
                valor = utils.pearson(data[x],data[y])
                matValor[x,y] = valor
                acum += valor
                if valor < tall:
                    vecImg[x] += 1
                    vecImg[y] += 1
                if valor > maxim:
                    maxim = valor
                if valor < minim:
                    minim = valor

        promig = acum/float(nm)

        if mostrar:
            print 
            print 'Cluster amb ' + str(n) + ' Imatges'
            print "-------------------------------------------"
            i = 0
            print "Mitja " + str(round(promig,3)) 
            print "Maxim " + str(maxim) 
            print "Minim " + str(minim) 
            print 'Repeticions de valors ' + str(vecImg)
            print 'Matriu: '
            print str(matValor)
            print '--------------------------------------------------'
      
        if promig < tallDown:
            if mostrar:
                print "|>>>>> Cluster expulsat per Pearson promig inferior a " + str(tallDown) + "  total imatges: "+ str(n) 
                print '------------------------------------------------------------------'
            outData, outLabels = [], []
            descarts, desReps = labels, data
        
            return [outData,outLabels,descarts,desReps] 
        
        
        if promig > tallUp:
            if mostrar:
                print "|<<<<< Cluster perfecte per coeficien Pearson promig superior a " + str(tallUp)  +  "  total imatges: "+ str(n)
                print '------------------------------------------------------------------'
        
            return [outData,outLabels,descarts,desReps] 
        
        
        for i in range(0,n):
            if vecImg[i] > int(n/2):
                remove.append(i)
                if mostrar:
                    print "|---> Expulsada per repetir "+ str(vecImg[i]) + " pasar-se la imatge " + labels[i].split('/')[-1]
                                   
        i = 0
        remove = sorted(remove)
        for rm in remove:
            descarts.append(outLabels.pop(rm-i))
            desReps.append(outData.pop(rm-i))
            i += 1
            
        if len(outLabels) == 1:
            descarts.append(outLabels.pop())
            desReps.append(outData.pop())
            #print str(desReps)
        
        return [outData,outLabels,descarts,desReps]  
                
    else:
        descarts.extend(outLabels)
        desReps.extend(outData)
        outData, outLabels = [], []
    
    return [outData,outLabels,descarts,desReps]  

# funcio per comprovar que un cluster les similituts de la roba
def revisarClothes(data,labels, tall = 0.40, tallUp = 0.80, tallDown = 0.00, desDownMax = 0.20, desMax = 0.10,  diff = 0.015, mostrar = True):
    descarts, desReps =[],[]
    outData, outLabels = data, labels

    if len(labels) > 2:
        n = len(data) 
        remove = []

        matValor = np.zeros((n,n))
        vecImg = [0 for x in range(0,n)]
        acum = 0.0
        nm = (n*(n-1))/2
        minim = float('Inf')
        maxim = float('-Inf')

        valor = 0.0
        for x in range(1,n):
            for y in range(0,x):
                valor = utils.bhattacharyya(data[x],data[y])
                matValor[x,y] = valor
                acum += valor
                if valor > tall:
                    vecImg[x] += 1
                    vecImg[y] += 1
                if valor > maxim:
                    maxim = valor
                if valor < minim:
                    minim = valor

        promig = acum/float(nm)

        if mostrar:
            print 
            print 'Cluster amb ' + str(n) + ' Imatges valor Bhattacharyya'
            print "-------------------------------------------"
            i = 0
            print "Mitja " + str(round(promig,3)) 
            print "Maxim " + str(maxim) 
            print "Minim " + str(minim) 
            print 'Repeticions de valors ' + str(vecImg)
            print 'Matriu: '
            print str(matValor)
            print '--------------------------------------------------'
              
        if promig > tallUp:
            if mostrar:
                print "|<<<<< Cluster perfecte per Bhattacharyya promig superior a " + str(tallUp)  +  "  total imatges: "+ str(n)
                print '------------------------------------------------------------------'
        
            return [outData,outLabels,descarts,desReps] 
        
        
        for i in range(0,n):
            if vecImg[i] > int(n/2):
                remove.append(i)
                if mostrar:
                    print "|---> Expulsada per repetir "+ str(vecImg[i]) + " pasar-se la imatge " + labels[i].split('/')[-1]
                                   
        i = 0
        remove = sorted(remove)
        for rm in remove:
            descarts.append(outLabels.pop(rm-i))
            desReps.append(outData.pop(rm-i))
            i += 1
            
        if len(outLabels) == 1:
            descarts.append(outLabels.pop())
            desReps.append(outData.pop())
            #print str(desReps)
        
        return [outData,outLabels,descarts,desReps]  
                
    else:
        descarts.extend(outLabels)
        desReps.extend(outData)
        outData, outLabels = [], []
    
    return [outData,outLabels,descarts,desReps] 


# Guardar les imatges amb un id concret
# clusters diccionaro amb keys ['images', 'reps', 'descarts', 'desReps', 'errors'] i afegit amb ['valors','clothes','sex'] on estan tots els valors de sexe i clothes
def saveImg(clusters , saveDir, args,  min_value = 0.85, min_cluster_value = 2):
    
    descarts = []
    
    if os.path.exists(saveDir):
        i = 0
        for reps in clusters['reps']:
            if len(reps) < min_cluster_value :
                descarts.extend(clusters['images'][i])
            #print 'Procesant imatges ' + str(clusters['images'][i])
            else:
                persones = utils.llistaDir(saveDir)
                
                nReps = len(reps)
                if len(persones) < 1:
                    persona = '0'
                else:
                    persona = '-1'
                    valorsMin = []
                    for persona in persones:
                        if os.path.exists(os.path.join(saveDir,persona,persona+'.csv')):
                            repsPresona = utils.readCsv(os.path.join(saveDir,persona,persona+'.csv'))
        
                            for repPersona in repsPresona:
                                r = 0
                                while r < nReps: 
                                    valor = utils.pearson(reps[r],repPersona)
                                    #valor = vecFace.compareVectors(reps[r],repPersona)
                                    if valor > min_value:
                                        valorsMin.append([valor,persona])
                                    r += 1
                    
                    if len(valorsMin) < 1:
                        persona = str(max([int(x) for x in persones])+1)
                    else:
                        persona = sorted(valorsMin, reverse=True)[0][1]
                    
                                        
                utils.movefiles(clusters['images'][i] , os.path.join(saveDir,persona) , accio = 'copy')
                for rep in reps:
                    utils.writeCsv(os.path.join(saveDir,persona,persona+'.csv'),rep)
                
                for clothe in clusters['clothes'][i]:
                    utils.writeCsv(os.path.join(saveDir,persona,persona+'_clothes.csv'),clothe)
                
                #Per determinar sexe de les imatges
                Nsex = [clusters['sex'][i].count(x) for x in [0,1]]
                s = Nsex.index(max(Nsex))
                for image in clusters['images'][i]:
                    lb = [persona,s,gd.gender_dict[s],image.split('/')[-1]]
                    utils.writeCsv(os.path.join(saveDir,persona,persona+'_sex_labels.csv'),lb)

            i += 1
            
        if len(descarts) > 0:    
            utils.moveImg([descarts],os.path.join(args.data_path,'_descarts'))
    else:
        print 'Directori no existeix'
    
