def extract_features(params):

    Train_or_Val_dic = {}
    
    with open(os.path.join(params['root'],params['root_save'],params['image_lists'],params['split'] + '.txt'),'r') as f:
        image_list = f.readlines()
    
   
    #Train_files= os.listdir(r'C:\Users\Albert\Documents\UNI\Q-5\GDSA\Projecte\TerrassaBuildings900\Train\images')
    #Val_files= os.listdir(r'C:\Users\Albert\Documents\UNI\Q-5\GDSA\Projecte\TerrassaBuildings900\Val\images')
    
    descriptors = []
    
    if params['split'] == 'train':
        
        for img in image_list:
            im = cv2.imread(os.path.join(params['root'],params['database'],params['split'],'images',img.rstrip()))
            
            # Resize image
            im = resize_image(params,im)
        
            des=get_local_features(params,im)
            
            if len(descriptors) == 0:
                descriptors = des
            else:
                descriptors = np.vstack((descriptors,des))
            
        code=train_codebook(params,descriptors)
        
        # Save to disk
        pickle.dump(code,open(os.path.join(params['root'],params['root_save'],
                                        params['codebooks_dir'],'codebook_'
                                        + str(params['descriptor_size']) + "_"
                                        + params['descriptor_type']
                                        + "_" + params['keypoint_type'] + '.cb'),'wb'))
    
    # Get trained codebook
    code = pickle.load(open(os.path.join(params['root'],params['root_save'],
                                     params['codebooks_dir'],'codebook_'
                                     + str(params['descriptor_size']) + "_"
                                     + params['descriptor_type']
                                     + "_" + params['keypoint_type'] + '.cb'),'rb'))
        
    for img in image_list:
        
        im = cv2.imread(os.path.join(params['root'],params['database'],params['split'],'images',img.rstrip()))
        # Resize image
        im = resize_image(params,im)
        des=get_local_features(params,im)
        assign=get_assignments(code,des)
        Train_or_Val_dic[img] = build_bow(assign,code)
        
    # Save dictionary to disk with unique name
    save_file = os.path.join(params['root'],params['root_save'],params['feats_dir'],
                             params['split'] + "_" + str(params['descriptor_size']) + "_"
                             + params['descriptor_type'] + "_" + params['keypoint_type'] + '.p')

    pickle.dump(Train_or_Val_dic,open(save_file,'wb'))
def get_features(params):
    #Obrim el fitxer que conte les ID de les imatges d'entrenament
    ID=open(os.path.join(params['root'],params['database'],'train','ImageIDs.txt'), 'r')
    #Extraccio de les caracteristiques de la imatge de la primera linia del ImageIDs.txt
    nom=str(ID.readline()).replace('\n','')
    desc_train=get_local_features(params,os.path.join(params['root'],params['database'],'train','images',nom + '.jpg'))
    #Extraccio de les caracteristiques per a la resta de les imatges d'entrenament
    dictrain=dict()
    dictrain[nom]=desc_train
    for line in ID:
        nom=str(line).replace('\n','')
        x=get_local_features(params,os.path.join(params['root'],params['database'],'train','images',nom + '.jpg'))
        #Concatenar les caracteristiques de cada imatge en una numpy array
        desc_train=np.concatenate((desc_train,x))
        dictrain[nom]=x
    #Tanquem el fitxer
    ID.close()

    #Entrenament del KMeans nomes per a les imatges d'entrenament amb 1024 paraules
    paraules=1024
    codebook=train_codebook(params,desc_train,paraules)
    #Obrim el fitxer que conte les ID de les imatges d'entrenament
    ID=open(os.path.join(params['root'],params['database'],'train','ImageIDs.txt'), 'r')

    for line in ID:
        nom=str(line).replace('\n','')
        #Calculem les assignacions per les imatges d'entrenament
        assignments=get_assignments(dictrain[nom],codebook)
        #Creacio del BoW per les imatges d'entrenament i emplenament del diccionari
        dictrain[nom]=build_bow(assignments,codebook,paraules)
    #Tanquem el fitxer
    ID.close()

    #Guardem el diccionari amb el BoW de les imatges d'entrenament en l'arxiu "Features.txt"
    bow_train = open (os.path.join(params['root'],params['database'],'train','Features.txt'), 'w')
    pk.dump(dictrain,bow_train)
    bow_train.close()

    #Obrim el fitxer que conté les ID de les imatges de validacio
    ID = open(os.path.join(params['root'],params['database'],'val','ImageIDs.txt'), 'r')
    #Creacio del diccionari de les imatges de validacio
    dicval=dict()
    for line in ID:
        #Extraccio de les caracteristiques per a les imatges de validacio
        x=get_local_features(params,os.path.join(params['root'],params['database'],'val','images',str(line).replace('\n','') + '.jpg'))
        #Calculem les assignacions per les imatges de validacio
        assignments=get_assignments(x,codebook)
        #Creacio del BoW per les imatges de validacio i emplenament del diccionari
        dicval[str(line).replace('\n','')]=build_bow(assignments,codebook,paraules)
    #Tanquem el fitxer
    ID.close()

    #Guardem el diccionari amb el BoW de les imatges de validacio en l'arxiu "Features.txt"
    bow_val = open (os.path.join(params['root'],params['database'],'val','Features.txt'), 'w')
    pk.dump(dicval,bow_val)
    bow_val.close()
Exemple #3
0
def codebook(params):

    
    with open(os.path.join(params['root'],params['root_save'],params['image_lists'],'train.txt'),'r') as f:
        train_image_list = f.readlines()
    
    with open(os.path.join(params['root'],params['root_save'],params['image_lists'], 'val.txt'),'r') as f:
        val_image_list = f.readlines()
    
     

    descriptors = []
    
    #if params['split'] == 'train':
        
    for img in train_image_list:
        im = cv2.imread(os.path.join(params['root'],params['database'],'train','images',img.rstrip()))
        
        # Resize image
        im = resize_image(params,im)
    
        des=get_local_features(params,im)
        
        if len(descriptors) == 0:
            descriptors = des
        else:
            descriptors = np.vstack((descriptors,des))
            
    print "descriptors train: "
    print np.shape(descriptors)
    for img in val_image_list:
        im = cv2.imread(os.path.join(params['root'],params['database'],'val','images',img.rstrip()))
        
        # Resize image
        im = resize_image(params,im)
    
        des=get_local_features(params,im)
        
        if len(descriptors) == 0:
            descriptors = des
        else:
            descriptors = np.vstack((descriptors,des))

    print "descriptors train + val: "
    print np.shape(descriptors)
    code=train_codebook(params,descriptors)
        
        # Save to disk
    pickle.dump(code,open(os.path.join(params['root'],params['root_save'],
                                        params['codebooks_dir'],'codebook_train_val'
                                        + str(params['descriptor_size']) + "_"
                                        + params['descriptor_type']
                                        + "_" + params['keypoint_type'] + '.cb'),'wb'))
def extract_features(params):

    feats_dic = {}
    
    with open(os.path.join(params['root'],params['root_save'],params['image_lists'],params['split'] + '.txt'),'r') as f:
        image_list = f.readlines()


    # Get trained codebook
    code = pickle.load(open(os.path.join(params['root'],params['root_save'],
                                     params['codebooks_dir'],'codebook_train_val_'
                                     + str(params['descriptor_size']) + "_"
                                     + params['descriptor_type']
                                     + "_" + params['keypoint_type'] + '.cb'),'rb'))
        
    for img in image_list:
        
        im = cv2.imread(os.path.join(params['root'],params['database'],params['split'],'images',img.rstrip()))
        im = resize_image(params,im)
        des = get_local_features(params,im)
        assign = get_assignments(code,des)
        feats_dic[img] = build_bow(assign,code)
        
    # Save dictionary to disk with unique name
    save_file = os.path.join(params['root'],params['root_save'],params['feats_dir'],
                             params['split'] + "_" + str(params['descriptor_size']) + "_"
                             + params['descriptor_type'] + "_" + params['keypoint_type'] + '.p')

    pickle.dump(feats_dic,open(save_file,'wb'))
Exemple #5
0
# -*- coding: utf-8 -*-
from sklearn.cluster import MiniBatchKMeans
from get_local_features import get_local_features
import sys

sys.path.insert(0, '/home/oscarlinux/Escritorio/UPC/Q5/GDSA/Projecte/')


def train_codebook(numClusters,
                   descriptores):  #Només para las imatges de train
    """Amb KMeans
    centroides,_= kmeans(descriptores, numClusters)"""

    #Amb MiniBatchKMeans (És més ràpid i més eficient que KMeans)
    centroides = MiniBatchKMeans(numClusters)
    centroides.fit(descriptores)

    return centroides  # retorna el vector codebook


if __name__ == "__main__":
    # Es per comprovar que la funció és correcta
    descriptors = get_local_features(
        "TerrassaBuildings900/train/images/aaeoeolbth.jpg")
    codebook1 = train_codebook(1, descriptors)
# -*- coding: utf-8 -*-
import os
from scipy.cluster.vq import vq
from get_local_features import get_local_features
from train_codebook import train_codebook
from sklearn.cluster import MiniBatchKMeans

ruta = os.path.dirname(
    os.path.abspath(__file__)
)  # Definim la instrucció principal que busca la ruta absoluta del fitxer


def compute_assignments(codebook, desc):
    assignments = codebook.predict(desc)  # calculem els assignaments
    return assignments


if __name__ == "__main__":
    dsc = []
    desc = get_local_features("../imagen_primerscript/people.jpg")
    desc2 = get_local_features("../imagen_primerscript/tiger.jpg")
    for feat in desc:
        dsc.append(feat)
    for feat in desc2:
        dsc.append(feat)
    codebook, _ = train_codebook(5, dsc)  # entrenem el codebook
    clase = compute_assignments(codebook, dsc)  # observem els assignaments
    )  #Normalitzem els valors entre 0 i 1 gràcies a la funció 'normalize'
    return BoW_norm[0]


if __name__ == "__main__":
    nfiles = os.listdir(
        "../imagen_primerscript")  #llistem els arxius del directori
    dsc = [
    ]  #inicialitzem el vector on aniran tots els descriptors de totes les imatges del directori
    BoW = dict()  #inicialitzem el diccionari
    dsc_ind = {
    }  #inicialitzem el vector que contindrá tots els descriptors de cada imatge
    for file in nfiles:
        filename = file[0:file.index(".")]  #obtenim el nom de l'arxiu
        dsc_ind[filename] = get_local_features(
            "../imagen_primerscript/" +
            file)  #dessem els descriptors de la imatge corresponent
        for feat in dsc_ind[filename]:
            dsc.append(
                feat
            )  #dessem tots els descriptors de totes les imatges al vector
    codebook, k = train_codebook(5, dsc)  #entrenem el codebook
    for file in nfiles:
        filename = file[0:file.index(".")]
        clase = compute_assignments(
            codebook, dsc_ind[filename])  #calculem els assignaments
        BoW[filename] = construct_bow_vector(
            clase, k)  #dessem els assignaments al vector BoW
    features = open("../files/features.p", 'w')
    pickle.dump(BoW, features)  #Escribim els assignaments al bow
    features.close()
import os.path as path

#dir = sys.path.insert(0,'./home/PycharmProjects/GDSA/Projecte/')
dir = path.dirname(__file__)

#dir = sys.path.insert(0,__file__)


def get_assignments(codebook, descriptors):

    #norm_descriptores = whiten(descriptores) # Normaliza descriptores
    #Con KMeans
    #assignments,_ = vq(descriptores, codebook)

    #Con MiniBatchKMeans
    assignments = codebook.predict(descriptors)
    return assignments


if __name__ == "__main__":

    descriptor1 = get_local_features(
        "TerrassaBuildings900/train/images/aaeoeolbth.jpg")
    codebook = train_codebook(5, descriptor1)
    descriptor2 = get_local_features(
        "TerrassaBuildings900/val/images/aalfirydrf.jpg")
    assig = get_assignments(codebook, descriptor2)

    print(assig)
    print "Longitud del assignments= " + str(len(assig))
# -*- coding: utf-8 -*-
from get_local_features import get_local_features
from sklearn.cluster import MiniBatchKMeans
import matplotlib.pyplot as plt
def train_codebook(nclusters,normalized_descriptors):
    km = MiniBatchKMeans(nclusters)
    km.fit(normalized_descriptors)
    i = km.get_params() #carreguem els params del vector k
    nc = i['n_clusters'] #obtenim el numero de clusters des de la clase minibatchkmeans
    return km, nc
    
    #return kmeans(normalized_descriptors,nclusters) #obtenim els centroides de les imatges

if __name__ == "__main__":
    desc = get_local_features("../imagen_primerscript/people.jpg") #obtenim els descriptors de la imatge
    centroides,nc = train_codebook(2,desc) #ccalculem els centroides de la imatge
    #plt.scatter(desc[:,0],desc[:,1]),plt.scatter(centroides[:,0],centroides[:,1],color = 'r'),plt.show() #mostrem els centroides i els descriptors
#-*- coding: utf-8 -*-
import os
from scipy.cluster.vq import vq
from get_local_features import get_local_features
from train_codebook import train_codebook
from sklearn.cluster import MiniBatchKMeans

ruta = os.path.dirname(
    os.path.abspath(__file__)
)  # Definim la instrucció principal que busca la ruta absoluta del fitxer


def compute_assignments(codebook, desc):
    assignments = codebook.predict(desc)  #calculem els assignaments
    return assignments


if __name__ == "__main__":
    dsc = []
    desc = get_local_features("../imagen_primerscript/people.jpg")
    desc2 = get_local_features("../imagen_primerscript/tiger.jpg")
    for feat in desc:
        dsc.append(feat)
    for feat in desc2:
        dsc.append(feat)
    codebook, _ = train_codebook(5, dsc)  #entrenem el codebook
    clase = compute_assignments(codebook, dsc)  #observem els assignaments
Exemple #11
0
dir = path.dirname(__file__)

#dir = sys.path.insert(0,__file__)
terrassa_buildings = '../TB2016/'



def build_bow(assignments, n):
    # Inicialitzem a zeros un vector de mida dels clusters
    descriptor = np.zeros((n,))

    # Construim un vector de repeticions.Cada assignments li atribuim un cluster
    for n_assig in assignments:
        descriptor[n_assig] += 1

    # L2 normalize
    descriptor = normalize(descriptor)

    return descriptor


# Comprovem que funciona
descriptor1 = get_local_features(path.join(terrassa_buildings, "../train/images/aaeoeolbth.jpg"))
codebook = train_codebook(5, descriptor1)
descriptor2 = get_local_features(path.join(terrassa_buildings, "../val/images/aalfirydrf.jpg"))
assig = get_assignments(codebook, descriptor2)

# Crea un vector ordenat amb els descriptors que equival a cada regio (k=5)
asdf = build_bow(assig, 50)
print asdf
print ("Numero de regiones diferentes: " + str(len(asdf)))
Exemple #12
0
# -*- coding: utf-8 -*-
from sklearn.cluster import MiniBatchKMeans
from get_local_features import get_local_features
import sys

sys.path.insert(0, './home/PycharmProjects/GDSA')


def train_codebook(numClusters,
                   descriptores):  #Només para las imatges de train
    """Amb KMeans
    centroides,_= kmeans(descriptores, numClusters)"""

    #Amb MiniBatchKMeans (És més ràpid i més eficient que KMeans)
    centroides = MiniBatchKMeans(numClusters)
    centroides.fit(descriptores)

    return centroides  # retorna el vector codebook


if __name__ == "__main__":
    # Es per comprovar que la funció és correcta
    descriptors = get_local_features("../TB2016/train/images/aaeoeolbth.jpg")
    codebook1 = train_codebook(1, descriptors)
import pickle

def construct_bow_vector(assignments,nclusters):
    #Paràmetres de la funcio: els assignments realitzadors sobre els descriptors.
    BoW_hist = np.zeros((nclusters, )) # Creerm una llista buida de k(número de clusters) valors igualats a cero.
    for a in assignments:
        BoW_hist[a] += 1 # Per cada entrada a l'assigments sumem 1 al índex que l'hi pertoca en el histograma.
    BoW_hist = np.float64(np.reshape(BoW_hist, (1,-1))) #corretgim el warning de reshape
    BoW_norm= preprocessing.normalize(BoW_hist)  #Normalitzem els valors entre 0 i 1 gràcies a la funció 'normalize'
    return BoW_norm[0]
    
if __name__ == "__main__":
    nfiles = os.listdir("../imagen_primerscript") #llistem els arxius del directori
    dsc = [] #inicialitzem el vector on aniran tots els descriptors de totes les imatges del directori
    BoW = dict() #inicialitzem el diccionari
    dsc_ind = {} #inicialitzem el vector que contindrá tots els descriptors de cada imatge
    for file in nfiles:
        filename = file[0:file.index(".")] #obtenim el nom de l'arxiu
        dsc_ind[filename] = get_local_features("../imagen_primerscript/" + file) #dessem els descriptors de la imatge corresponent
        for feat in dsc_ind[filename]:
            dsc.append(feat) #dessem tots els descriptors de totes les imatges al vector
    codebook,k = train_codebook(5,dsc) #entrenem el codebook
    for file in nfiles:
        filename = file[0:file.index(".")]
        clase = compute_assignments(codebook, dsc_ind[filename]) #calculem els assignaments
        BoW[filename] = construct_bow_vector(clase,k) #dessem els assignaments al vector BoW
    features = open("../files/features.p",'w') 
    pickle.dump(BoW,features) #Escribim els assignaments al bow
    features.close()
    feat = open("../files/features.p",'r')
    p = pickle.load(feat)    
Exemple #14
0
from train_codebook import train_codebook
from get_assignments import get_assignments
from build_bow import build_bow
from get_params import get_params
import warnings
warnings.filterwarnings("ignore")
params = get_params()

#Obrim el fitxer que conte les ID de les imatges d'entrenament
ID = open(
    os.path.join(params['root'], params['database'], 'train', 'ImageIDs.txt'),
    'r')
#Extraccio de les caracteristiques de la imatge de la primera linia del ImageIDs.txt
nom = str(ID.readline()).replace('\n', '')
desc_train = get_local_features(
    params,
    os.path.join(params['root'], params['database'], 'train', 'images',
                 nom + '.jpg'))
#Extraccio de les caracteristiques per a la resta de les imatges d'entrenament
dictrain = dict()
dictrain[nom] = desc_train
for line in ID:
    nom = str(line).replace('\n', '')
    x = get_local_features(
        params,
        os.path.join(params['root'], params['database'], 'train', 'images',
                     nom + '.jpg'))
    #Concatenar les caracteristiques de cada imatge en una numpy array
    desc_train = np.concatenate((desc_train, x))
    dictrain[nom] = x
#Tanquem el fitxer
ID.close()