def get_same_imgs(img, imgs, dictionary, n=5):
"""
Función que recibe una imagen (img) y devuelve en un vector las (n)
imágenes (imgs) con mayor coincidencia de entre todas las disponibles.
imgs contiene todas las imágenes que forman parte de la base de datos.
dictionary tendrá la ruta+nombre del fichero con el vocabulario.
"""
# Se carga el diccionario recibido con la función que se encuentra en
# auxFunc.py. Se devuelve la precisión, etiquetas y el vocabulario
accuracy, labels, dictionary = aux.loadDictionary(dictionary)
# Primero se obtienen los descriptores de la imagen
keypoints, descriptors = get_keypoints_descriptors(img)
# Se calcula el histograma de la imagen-pregunta
histogram_query = get_histogram(dictionary, descriptors)
# Se crea un contenedor donde se almacenará cada resultado al comparar el
# histograma de la imagen-pregunta
res_histograms = []
# Se calcula el histograma de cada imagen que forma parte de la base de
# datos y se compara el histograma con el de la imagen-pregunta
for img_aux in imgs:
# Se obtienen los descriptores de la imagen actual
keypoints, descriptors = get_keypoints_descriptors(img_aux)
# Se guarda el histograma correspondiente de cada imagen
histogram = get_histogram(dictionary, descriptors)
# Se compara el histograma de la imagen-pregunta con cada histograma de
# las imágenes de la base de datos
value_compare = compare_histograms(histogram_query, histogram)
# Se añaden los resultados al contenedor
res_histograms.append(value_compare)
# Para ordenar los mejores resultados y obtener los índices, se utiliza
# np.argsort(). sorted_res contiene una lista
sorted_res = np.argsort(np.array(res_histograms))
# Se quieren elegir las n mejores imágenes, por lo que se seleccionan las
# n últimas (está ordenado de peor a mejor)
best = sorted_res[:len(sorted_res) - n - 1:-1]
# Se recorren los índices y se devuelve una lista con las mejores imágenes
best_imgs = []
for i in best:
best_imgs.append(imgs[i])
return best_imgs
####################################################################################
# EJECUCIÓN EJERCICIO 2
####################################################################################
# Lo primero es cargar las imágenes. Son 441 en total.
images = []
for i in range(0, 441):
ruta = 'imagenes/' + str(i) + '.png'
img = cv2.imread(ruta)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
images.append(img)
# Cargamos el diccionario con la función auxiliar
accuracy, labels, dictionary = aux.loadDictionary(
'imagenes/kmeanscenters2000.pkl')
# Creamos un objeto IndiceInvertido
indiceInvertido = IndiceInvertido(dictionary, images)
# Vamos a probar a ver, por ejemplo, 3 imágenes que contienen la palabra 288
img288 = indiceInvertido.GetIndiceInvertido(288)
# No sabemos como es la palabra, pero vemos que funciona
for i in img288[20:23]:
plt.title('Imagenes con la palabra nº 288')
plt.imshow(images[i])
plt.show()
input("Pulsa enter para continuar...")
# for i in range (len(dictionary)):
best_patches = []
indexes = []
for j in matches[i]:
best_patches.append(
cv.cvtColor(resized_patches[j.trainIdx], cv.COLOR_RGB2GRAY))
indexes.append(j.trainIdx)
multiple_images(best_patches, indexes,
'Parches mas cercanos a la palabra ' + str(i))
if __name__ == '__main__':
# Lectura de archivos
r_list = read_images('imagenes/', 441)
dictionary = Funcs.loadDictionary('kmeanscenters2000.pkl')
patches = Funcs.loadAux('descriptorsAndpatches2000.pkl', True)
# Comienzo de ejercicios
print("Criterio de Lowe")
thr = [0.7, 0.7, 0.7]
ejercicio_1(r_list.copy(), thr)
print("Ratio respectivamente: 0.75, 0.7, 0.75")
thr = [0.75, 0.7, 0.75]
ejercicio_1(r_list.copy(), thr)
print("Ratio respectivamente: 0.8, 0.7, 0.85")
thr = [0.87, 0.7, 0.85]
ejercicio_1(r_list.copy(), thr)
import collections
import random
import auxFunc
#########################
# PARÁMETROS AJUSTABLES #
#########################
# Carga y visualización de imágenes
PATH = "imagenes/" # Carpeta de imágenes
COLOR, GRIS = cv.IMREAD_COLOR, cv.IMREAD_GRAYSCALE
# Carga de datos de k medias
KMEANS_FILENAME = "kmeanscenters2000.pkl"
np.seterr(divide='ignore', invalid='ignore') # evitar errores por norma cero
_, _, kmeans = auxFunc.loadDictionary(KMEANS_FILENAME)
KMEANS_DICT = kmeans / np.linalg.norm(kmeans, axis=1).reshape(
(kmeans.shape[0], 1))
# Carga de datos de parches
PATCHES_FILENAME = "descriptorsAndpatches2000.pkl"
PT_DESC, PATCHES = auxFunc.loadAux(PATCHES_FILENAME, True)
# Objetos SIFT y SURF con parámetros elegidos
SIFT = cv.xfeatures2d.SIFT_create()
########################
# FUNCIONES AUXILIARES #
########################
def get_areas(dictionary,
descriptors_and_patches,
index=None,
n_best=20,
get_cluster=True):
"""
Se recibe un vocabulario (dictionary) con muchas palabras que contienen
trozos de imágenes. Con la lista de descriptores y parches
(descriptors_and_patches) se agrupan los parches en sus respectivos clusters
y eligen los (n) mejores teniendo en cuenta su centroide que se encuentra en
el vocabulario. Se calcula la varianza de cada cluster con los (n_best)
mejores parches y se ordenan de menor varianza a mejor. Se devuelven los
clusters que se estén en la posición que indica "index".
Si "get_cluster" es verdadero, "index" se refiere al índice del clúster,
si es falso, se refiere al "index" mejor clúster.
"""
# Se carga el fichero con los descriptores y parches
descriptors, patches = aux.loadAux(descriptors_and_patches, True)
# Se carga el diccionario recibido con la función que se encuentra en
# auxFunc.py. Se devuelve la precisión, etiquetas y el vocabulario
accuracy, labels, dictionary = aux.loadDictionary(dictionary)
# Se crea un diccionario auxiliar para hacer las operaciones intermedias
d = dict()
# Se recorre cada descriptor
for i, descriptor in enumerate(descriptors):
# Se comprueba el clúster al que pertenece el descriptor
label = labels[i][0]
# Se calcula la distancia euclídea entre el descriptor y el centroide
# de su clúster
distance = get_distance(dictionary[label], descriptor)
# Si el clúster aparece en el diccionario auxiliar se añade la posición
# que ocupa en la lista de descriptores y la distancia con su centroide.
# Si no existe se crea el contenedor y se añade.
if label in d:
d[label][0].append(i)
d[label][1].append(distance)
else:
d[label] = [[i], [distance]]
# Se crean tres estructuras para poder operar con los datos.
# Lista que contiene los (best) mejores parches de cada clúster.
best_patches = []
# Lista que contiene las varianzas de cada clúster
variances = []
# Lista que contiene las etiquetas de los clusters
clusters = []
# Se recorren los clusters guardados en el diccionario auxiliar
for cluster in d:
# Se ordenan los parches del clúster según su varianza (de menor a
# mayor varianza) y se guardan en "s" los "n_best" mejores
s = np.argsort(np.array(d[cluster][1]))[0:n_best]
# Se crea una lista donde se añadirán los mejores parches del clúster
best = []
# Se crea una lista para guardar la varianza de cada parche elegido en
# el clúster
var = []
# Se guardan los mejores parches y sus varianzas
for i in s:
best.append(patches[d[cluster][0][i]])
var.append(d[cluster][1][i])
# Se guardan los "best" mejores parches en la lista que contiene todos
# los clusters
best_patches.append(best)
# Se guarda la varianza de los "best" mejores parches
variances.append(np.var(best))
# Se guarda la etiqueta del clúster
clusters.append(cluster)
# Se ordenan los clúster por su varianza de menor a mayor
s = np.argsort(np.array(variances))
"""
Para mostrar una lista con todas las imágenes y sus datos asociados:
"""
"""
for i in reversed(range(len(clusters)-100, len(clusters))):
print("Cluster: ",clusters[s[i]], ", Iteración: ", i, ", Varianza: ", \
variances[s[i]])
show_images(best_patches[s[i]])
"""
# Se crea la lista con los clusters que se quieren devolver
imgs = []
# Se guardan los índices de mejor a peor
if not get_cluster:
# Se recorren los índices que se quieren devolver
for i in index:
# Se guarda el clúster de "best" parches
imgs.append((clusters[s[i]], best_patches[s[i]]))
else:
# Se guardan los clusters
# Se recorren los índices que se quieren devolver
for i in index:
# Se guarda el clúster de "best" parches
imgs.append((clusters[s[i]], best_patches[clusters.index(i)]))
# Se devuelven los clusters
return imgs