PFC Reconocimiento Facial Mediante VisiÃ N Artificial

DEPARTAMENTO DE INGENIERA DE
SISTEMAS Y AUTOMTICA
ESCUELA TCNICA SUPERIOR DE INGENIEROS
UNIVERSIDAD DE SEVILLA
PROYECTO FIN DE CARRERA
RECONOCIMIENTO FACIAL
MEDIANTE VISIN
ARTIFICIAL
INGENIERA DE TELECOMUNICACIN
Autor:
Csar Reyes Lpez
Tutor:
Dr. Eduardo Fernndez Camacho
Sevilla, Mayo de 2005

RECONOCIMIENTO FACIAL MEDIANTE VISIN ARTIFICIAL
Csar Reyes Lpez
Pgina 1

NDICE
1. MOTIVACIN Y OBJETIVOS.................................................... 7
1.1.
INTRODUCCIN ......................................................................................................... 7
1.2.
OBJETIVOS ................................................................................................................. 8
1.3.
ORGANIZACIN DE LA MEMORIA ............................................................................ 9
2. INTRODUCCIN TERICA .................................................... 11

2.1.
ESTRUCTURA........................................................................................................... 11
2.2.
ESTADOS DEL ARTE................................................................................................ 12
2.2.1.
INTRODUCCIN................................................................................................... 12
2.2.2.
MTODO DE TRABAJO ....................................................................................... 13
2.2.3.
ALGORITMOS....................................................................................................... 14
2.3.
2.2.3.1.
Correlacin y FFT......................................................................................................16
2.2.3.2.
PCA y Eigenfaces......................................................................................................18
2.2.3.3.
Basado en Parmetros (LFA) ....................................................................................18
2.2.3.4.
Basado en Redes Neuronales...................................................................................21
2.2.3.5.
Basado en Plantillas ..................................................................................................23
TCNICAS EMPLEADAS .......................................................................................... 25
2.3.1.
DETECCIN DE CARAS ...................................................................................... 25
2.3.2.
RECONOCIMIENTO FACIAL................................................................................ 26
2.3.2.1.
TRABAJO PREVIO: correlacin y FFT......................................................................27
2.3.2.2.
PCA Y EIGENFACES................................................................................................29
2.3.3.
REALCE MEDIANTE IGUALACIN DE HISTOGRAMA ...................................... 36
3. COMPONENTES DEL SISTEMA ............................................ 40

3.1.
ESTRUCTURA........................................................................................................... 40
3.2.
ENTORNO DE TRABAJO.......................................................................................... 41
3.2.1.
FUENTE DE ILUMINACIN.................................................................................. 41
3.2.1.1.
Fuente de iluminacin directa....................................................................................41
Csar Reyes Lpez
Pgina 2

3.2.1.2.
Fuente de iluminacin arbitraria ................................................................................42
3.2.1.3.
Iluminacin del entorno de trabajo.............................................................................42
3.2.2.
ENTORNO ESTRUCTURADO.............................................................................. 42
3.2.3.
CMARA WEB ...................................................................................................... 43
3.2.4.
EQUIPO INFORMTICO ...................................................................................... 45
3.3.
ENTORNO DE PROGRAMACIN ............................................................................ 45
3.3.1.
OPENCV................................................................................................................ 45
3.3.2.
MICROSOFT VISUAL C++ 6.0 ............................................................................. 47
4. IMPLEMENTACIN................................................................. 48
4.1.
ESTRUCTURA........................................................................................................... 48
4.2.
DISEO ..................................................................................................................... 49
4.2.1.
DIAGRAMA DE FLUJO ......................................................................................... 49
4.2.2.
ESTRUCTURA INTERNA ..................................................................................... 52
4.2.2.1.
MAIN Funcin principal...........................................................................................52
4.2.2.2.
NUEVO USUARIO ....................................................................................................55
4.2.2.3.
RECONOCIMIENTO .................................................................................................56
4.2.2.4.
SALIR ........................................................................................................................56
4.2.3.
FUNCIONES INTERNAS ...................................................................................... 56
4.2.3.1.
Funciones de librera de C++ ....................................................................................56
4.2.3.2.
Funciones de Librera de OpenCV ............................................................................56
4.2.3.2.1.
4.2.3.2.2.
4.2.3.2.3.
4.2.3.2.4.
4.2.3.2.5.
4.2.3.2.6.
4.2.3.2.7.
4.2.3.2.8.
4.2.3.2.9.
4.2.3.2.10.
4.2.3.2.11.
4.2.3.2.12.
4.2.3.2.13.
4.2.3.2.14.
4.2.3.2.15.
4.2.3.2.16.
4.2.3.2.17.
4.2.3.2.18.
4.2.3.2.19.
4.2.3.2.20.
4.2.3.2.21.
4.2.3.2.22.
cvLoadImage ........................................................................................................56
cvSaveImage ........................................................................................................56
cvNamedWindow..................................................................................................57
cvShowImage .......................................................................................................57
load_object_detector ............................................................................................57
detect_and_draw_object.......................................................................................57
cvDestroyAllWindows ...........................................................................................58
cvCalcEigenObjects..............................................................................................58
cvEigenProjection .................................................................................................58
cvEigenDecomposite ...........................................................................................59
cvReleaseImage ..................................................................................................59
cvReleaseCapture ...............................................................................................59
cvCreateMemStorage ..........................................................................................60
cvReleaseMemStorage........................................................................................60
cvPyrDown...........................................................................................................60
cvHaarDetectObjects ...........................................................................................60
cvGetSeqElem .....................................................................................................61
cvRectangle .........................................................................................................61
cvResize ..............................................................................................................61
cvCaptureFromCAM ............................................................................................62
cvGrabFrame .......................................................................................................62
cvRetrieveFrame..................................................................................................62
Csar Reyes Lpez
Pgina 3

4.2.3.2.23.
4.2.3.2.24.
4.2.3.2.25.
4.2.3.2.26.
4.2.3.3.
cvCopy.................................................................................................................62
cvFlip ...................................................................................................................63
cvCvtColor ...........................................................................................................63
cvWaitkey ............................................................................................................63
Funciones Propias .....................................................................................................64
4.2.3.3.1.
4.2.3.3.2.
4.2.3.3.3.
4.2.3.3.4.
4.2.3.3.5.
4.2.3.3.6.
4.2.3.3.7.
4.2.3.3.8.
camara_y_foto ......................................................................................................64
almacena ..............................................................................................................64
guarda_foto...........................................................................................................64
compara................................................................................................................65
realce_mono .........................................................................................................66
parecido ................................................................................................................66
extract_and_norm .................................................................................................66
guardian................................................................................................................67
4.3.
FUNCIONAMIENTO .................................................................................................. 67
4.4.
CRITERIOS PARA EL RECONOCIMIENTO ............................................................. 76
4.4.1.
4.5.
COMPARA. Realce y Eigenfaces.......................................................................... 84
RESULTADOS........................................................................................................... 89
5. CONCLUSIONES Y LNEAS DE DESARROLLO FUTURAS. 91

5.1.
ESTRUCTURA........................................................................................................... 91
5.2.
CONCLUSIONES ...................................................................................................... 91
5.3.
LNEAS DE DESARROLLO FUTURAS ..................................................................... 92
6. BIBLIOGRAFA........................................................................ 97
7. ANEXOS ................................................................................ 101
7.1.
GUIA DE USUARIO ................................................................................................. 101
7.2.
OBSERVACIONES.................................................................................................. 104
7.3.
CDIGO FUENTE ................................................................................................... 106
7.4.
FICHEROS DE TEXTO............................................................................................ 122
Csar Reyes Lpez
Pgina 4

NDICE DE ILUSTRACIONES
Ilustracin 1: (a) y (c) imgenes faciales originales, (b) y (d) imgenes binarias de bordes. __ 19
Ilustracin 2: Ejemplos de redes neuronales ______________________________________ 22
Ilustracin 3: Ejemplo de Red Neuronal para Reconocimiento Facial ___________________ 23
Ilustracin 4: Ejemplo de Reconocimiento Facial por plantillas ________________________ 24
Ilustracin 5: Ejemplo de correlacin de caras. Caras y FFT __________________________ 28
Ilustracin 6: Ejemplo de correlacin de frontales de coches y camiones ________________ 29
Ilustracin 7: Ejemplo de base de datos de caras (Fuente FERET) _____________________ 33
Ilustracin 8: Eigenfaces de las caras anteriores ___________________________________ 33
Ilustracin 9: Cara original e histograma__________________________________________ 37
Ilustracin 10: Funcin de Distribucin ___________________________________________ 38
Ilustracin 11: Cara realzada e histograma _______________________________________ 38
Ilustracin 12: Diagrama de flujo del programa principal _____________________________ 50
Ilustracin 13: Diagrama de flujo de la funcin COMPARA ___________________________ 51
Ilustracin 14: Imgenes de la base de datos______________________________________ 53
Ilustracin 15: Interfaz Grfica. Pantalla inicial _____________________________________ 54
Ilustracin 16: Pantalla inicial __________________________________________________ 68
Ilustracin 17: Nmero de opcin introducido incorrecto _____________________________ 69
Ilustracin 18: Opcin 0, Nuevo Usuario__________________________________________ 69
Ilustracin 19: Introduccin del nombre del nuevo usuario Cesar Demo ______________ 70
Ilustracin 20: Cara de usuario Cesar Demo detectada ___________________________ 70
Ilustracin 21: Fichero caras.txt con el nuevo usuario almacenado ____________________ 71
Ilustracin 22: Captura de una fotografa de usuario con mala posicin _________________ 72
Ilustracin 23: Error, No se ha encontrado una cara _______________________________ 72
Ilustracin 24: Opcin 1, Reconocimiento_________________________________________ 73
Ilustracin 25: Usuario Reconocido. Acceso Permitido_______________________________ 74
Ilustracin 26: Caras de usuario actual y parecido (Reconocimiento correcto) ____________ 74
Ilustracin 27: Usuario No Reconocido. Acceso Denegado ___________________________ 75
Ilustracin 28: Valores de las distancias entre caras ________________________________ 77
Ilustracin 29: Valores inversos de las distancias entre caras _________________________ 80
Ilustracin 30: Ejemplo de reconocimiento fallido. No cumple 2 condicin _______________ 81
Ilustracin 31: Cumplimiento de la 3 condicin de reconocimiento _____________________ 82
Ilustracin 32: Fallo en el cumplimiento de la 1 y 2 condicin de reconocimiento _________ 83
Ilustracin 33: Ejemplo. Imgenes de la base de datos ______________________________ 84
Ilustracin 34: Imgenes originales y realzadas en escala de grises ____________________ 86
Ilustracin 35: Eigenfaces _____________________________________________________ 88
Ilustracin 36: Imagen del usuario a reconocer. Original y realzada ____________________ 88
Ilustracin 37: Tabla de resultados ______________________________________________ 89
Ilustracin 38: Icono de Instalacin de la librera OpenCV ___________________________ 102
Ilustracin 39: Face_Training.xml ______________________________________________ 103
Ilustracin 40: Ejecutar programa de Reconocimiento Facial _________________________ 103
Csar Reyes Lpez
Pgina 5

Csar Reyes Lpez
Pgina 6

1. MOTIVACIN Y OBJETIVOS
1.1. INTRODUCCIN
En los ltimos aos, el desarrollo de nuevo hardware y software
informtico para sistemas de seguridad ha experimentado un gran impulso, tal
es el caso de los sistemas de reconocimiento por huella dactilar, voz, iris y
facial. Entre estos, destaca por perfilarse como el ms prometedor el
reconocimiento facial.
La identificacin de caractersticas faciales ha recibido un fuerte impulso
gracias al avance en la tecnologa de video multimedia propicindose as un
aumento de cmaras en los lugares de trabajo y en el hogar con un reducido
coste. El reconocimiento facial se puede aplicar en el control de accesos a
edificios pblicos y privados, cajeros automticos, laboratorios de investigacin
y tambin como clave secreta de acceso para el uso de ordenadores
personales o terminales mviles de ltima generacin.
Podran utilizarse estos sistemas para tener bases de datos con las
personas que entran y salen de lugares emblemticos, como ya se ha hecho
Csar Reyes Lpez
Pgina 7

en EEUU durante la ltima final de ftbol americano, conocida como Super

Bowl, donde las cmaras registraron las caras de cada uno de los
espectadores para contrastarlas con las de los criminales y sospechosos
almacenadas en sus bases de datos.
El proceso de identificacin facial se divide en dos tareas: deteccin y
reconocimiento. La primera de ellas, la deteccin, comprende la localizacin
de una o varias caras dentro de una imagen, ya sea una imagen fija, fotografa
o una secuencia de video. La segunda tarea, el reconocimiento, consiste en la
comparacin de la cara detectada con anterioridad con otras almacenadas
previamente
en
una
base
de
datos.
Estos
procesos,
deteccin
reconocimiento, no deberan ser totalmente independientes, debido a que

segn la forma en la que se detecte una cara puede ser imposible su
reconocimiento con caras de una base de datos detectadas de manera
diferente, de ah que los sistemas de reconocimiento facial estn fuertemente
condicionados por la posicin y orientacin de la cara del sujeto con respecto a
la cmara y las condiciones de iluminacin, en el momento de realizar la
deteccin facial.
1.2. OBJETIVOS
El objetivo de este proyecto es la creacin de un software de
reconocimiento facial que utilice como medio de captacin de imgenes una
cmara web.
Se ha considerado este proyecto como parte de una instalacin
domtica, lo que ha conllevado una serie de restricciones e imposiciones
respecto a sus caractersticas.
De las muchas aplicaciones que puede ofrecer una vivienda inteligente,
una de ellas es la seguridad. Un sistema de reconocimiento facial sera parte
importante de est, permitiendo o denegando el acceso a aquellas personas
ajenas a la vivienda o enclave residencial que no pertenecieran a una base de
datos propia o no tuvieran el permiso requerido. Adems, un sistema de
Csar Reyes Lpez
Pgina 8

reconocimiento facial proporciona al usuario cierta comodidad con respecto a

otros sistemas, como por ejemplo, memorizacin de cdigos en sistemas de
marcacin digital o prdidas u olvidos de tarjetas o llaves en sistemas con
cerraduras. Sin embargo, los sistemas de reconocimiento facial se utilizan
conjuntamente con alguno de los anteriores, ya que como se ha comentado,
una de las aplicaciones o caractersticas de una vivienda domtica es la
seguridad y por tanto, la diversidad de sistemas aumenta sta.
Por formar parte de una instalacin domtica la solucin aportada deba
de cumplir ciertos requisitos, uno de ellos era la utilizacin de una cmara web
como sistema de captacin de imgenes, dado su bajo coste y su alta
implantacin en el mercado de consumo de los ordenadores personales. Otro
requisito, quizs el ms restrictivo respecto al software, era que el tiempo de
procesado desde la captura de la cara del usuario hasta la indicacin de su
acceso o prohibicin de entrada fuese de un par de segundos como mximo.
Por tanto, el software desarrollado, ha sido diseado de forma
experimental e intuitiva, es decir, las funciones son robustas, pero la interfaz
grfica es sencilla, puesto que lo que se pretende es ilustrar el correcto
funcionamiento del mtodo desarrollado, dejando para un posterior trabajo su
insercin dentro de un sistema global en una instalacin domtica.
1.3. ORGANIZACIN DE LA MEMORIA

La memoria se ha estructurado en siete captulos. El primero de ellos
realiza una introduccin al reconocimiento facial y describe los objetivos que se
pretenden conseguir con este proyecto fin de carrera.
El segundo captulo realiza en primer lugar una introduccin terica a los
sistemas de reconocimiento facial y sus distintas tcnicas de realizacin, lo que
se ha denominado como Estados del Arte, as como una descripcin del
mtodo de trabajo a seguir y ejemplos de diferentes algoritmos matemticos
con los que implementar dicho sistema. En una segunda parte detalla las
diferentes tcnicas elegidas y empleadas para la consecucin de los objetivos
Csar Reyes Lpez
Pgina 9

iniciales del proyecto, tanto para la deteccin como para el reconocimiento de

caras, as como el uso de otras herramientas matemticas utilizadas, como es
el realce de imgenes mediante la igualacin de histograma.
El captulo tercero describe las componentes del sistema, tanto las
pertenecientes al entorno de trabajo: fuente de iluminacin, cmara web y
equipo informtico, como las pertenecientes al entorno de programacin:
libreras y programas software utilizados.
El captulo cuarto muestra cmo se ha llevado a cabo la implementacin
del sistema de reconocimiento facial partiendo del diseo, diagramas de flujo,
descripcin de la estructura interna del sistema y funciones de librera utilizadas
y diseadas, hasta una descripcin detallada de su funcionamiento que incluye
capturas de pantalla con la ejecucin del programa. Se describen tambin en
este captulo los diferentes criterios necesarios para el reconocimiento as
como un apartado de resultados.
El siguiente captulo, el quinto, muestra las conclusiones a las que se ha
llegado tras el diseo y prueba del sistema, as como las diferentes lneas de
desarrollo futuras con las que continuar el trabajo realizado.
La bibliografa ocupa el captulo sexto. Se indican, tanto los volmenes
que versan sobre reconocimiento facial y visin artificial, como los de
programacin en C++. Adems, se incluyen multitud de enlaces a sitios web
donde se dispone de informacin y material adicional e interesante sobre las
diferentes partes y materias de las que consta el proyecto fin de carrera
realizado.
En el ltimo captulo, se incluye una gua de usuario que explica los pasos
a realizar para la ejecucin del programa de reconocimiento facial diseado. Un
apartado de observaciones, y el listado del cdigo fuente del programa as
como los ficheros de texto auxiliares que este utiliza.
Csar Reyes Lpez
Pgina 10

2. INTRODUCCIN TERICA
2.1. ESTRUCTURA
En este apartado se realiza una introduccin a las tcnicas y
conocimientos tericos requeridos para la ejecucin del proyecto as como una
visin de los diferentes mtodos de trabajo y estudios realizados hasta la fecha.
En una primera seccin se detalla como ha sido estudiado el problema
del reconocimiento facial, el mtodo de trabajo y las diferentes tcnicas
empleadas para la resolucin del mismo.
En la segunda y ltima parte se detallan las tcnicas empleadas en este
proyecto para la consecucin de los objetivos iniciales en el proceso del
reconocimiento facial, diferencindose entre tcnica para la deteccin de caras
dentro de una imagen y tcnica para el reconocimiento de dicha cara una vez
detectada.
Csar Reyes Lpez
Pgina 11

2.2. ESTADOS DEL ARTE

2.2.1.
INTRODUCCIN
La cara es nuestro principal centro de atencin en el trato social,

desempeando un papel muy importante en la identificacin personal y
emocional.
Los seres humanos, somos capaces de reconocer multitud de caras
aprendidas a lo largo de nuestra vida e identificar rostros familiares de un
vistazo incluso despus de varios aos de separacin. Esta destreza es
bastante robusta a pesar de grandes cambios en los estmulos visuales
debidos a condiciones de iluminacin, expresin, edad o de distraccin tales
como gafas, cambios en el peinado, barba o bigote. Esta capacidad de
procesado visual y reconocimiento de caras humanas ha fascinado a filsofos y
cientficos durante siglos, incluyendo a figuras tales como Aristteles y Darwin.
El desarrollo de modelos y sistemas de reconocimiento facial es
bastante difcil, debido a que estos modelos son complejos, multidimensionales
y manejan estmulos visuales sujetos a multitud de condiciones.
Muchos de los trabajos de reconocimiento facial por ordenador han sido
enfocados hacia la deteccin de caractersticas individuales tales como ojos,
nariz, boca, contorno de la cabeza, definiendo un modelo facial mediante
posicin, tamao, y relaciones entre stas, es decir, distancia entre ojos,
distancia entre orejas, tamao de la frente, etc. Sin embargo, estos sistemas
presentan una gran dificultad a la hora de extenderse a mltiples y diferentes
vistas, convirtindose en sistemas frgiles, requiriendo un muy buen
entrenamiento inicial. Adems estos sistemas tienen un elevado coste
computacional y por lo tanto un elevado tiempo de procesado.
Sin dejar de lado la idea subyacente en los sistemas anteriormente
nombrados, actualmente se buscan mtodos de reconocimiento basados en la
bsqueda de informacin significativa contenida en "caractersticas" locales y
globales. Tales "caractersticas", pueden o no estar relacionadas, ni ser las que
Csar Reyes Lpez
Pgina 12

intuitivamente podran entenderse como caractersticas faciales tales como

ojos, labios, etc.
Lo que se pretende, en trminos de la teora de la informacin, es
extraer la informacin relevante contenida en una imagen facial, codificarla de
la manera ms eficiente posible, y compararla con la informacin almacenada
en una base de datos creada a tal efecto. Una primera y simple aproximacin a
la extraccin de esta informacin contenida en una imagen facial podra ser
capturar la variacin en una coleccin de imgenes independientes y
diferentes, de ciertas caractersticas, y usar est informacin para codificar y
comparar imgenes de caras de manera individual.
En trminos matemticos, lo que se desea es encontrar los
componentes principales de una distribucin de caras, es decir, una serie de
valores indicativos de la variacin de la informacin contenida en cada una de
las imgenes de caras.
2.2.2.
MTODO DE TRABAJO
Como ya se ha comentado con anterioridad, un sistema de

reconocimiento facial puede dividirse en dos etapas o fases, deteccin y
reconocimiento:
- Deteccin. Para realizar la deteccin de una cara, primero ha de
tenerse una imagen. Esta imagen de entrada puede ser una sola capturada a
travs de un sensor, cmara, etc, o varias desde diferentes ngulos para
permitir una bsqueda ms exacta. La deteccin de caras puede realizarse de
manera esttica: dada una imagen arbitraria y fija, hallar la localizacin de la o
las caras que contenga; o dinmica o en tiempo real donde dada una
secuencia de video arbitraria, hallar la localizacin de la o las caras que
contenga en cada fotograma o para una secuencia de los mismos.
- Reconocimiento. El proceso de reconocimiento consta en primer lugar
de la extraccin de caractersticas relevantes de la cara detectada y su
posterior normalizacin y acondicionamiento para una mejor representacin y
Csar Reyes Lpez
Pgina 13

almacenamiento posterior en la base de datos. En segundo lugar ha de

realizarse la comparacin del rostro normalizado con el conjunto o
subconjuntos
resultantes
de
una
previa
clasificacin
de
los
rostros
normalizados en la base de datos del sistema. Ha de proporcionarse un

porcentaje de similitud o un valor equivalente para poder disponer de un umbral
con el que discernir si un rostro pertenece o no a la base de datos.
Por tanto, una vez que el nuevo rostro se ha procesado y se tiene un
valor de similitud con respecto a la base de datos del sistema, ya se ha
reconocido, entendindose por reconocimiento en este caso, y segn como se
definiera en un principio dicho valor de similitud, el admitir dicho rostro como
perteneciente a la base de datos o no. Con lo cual, aplicando lo anterior a un
sistema de acceso residencial, por ejemplo, segn dicho valor, se permitira o
no el acceso al interior de un usuario al que se le capturara una imagen de su
cara en el momento de intentar entrar.
De los dos procesos en los que se puede dividir un sistema de
reconocimiento facial y en cuanto al tiempo total de procesado, el ms
determinante es el de reconocimiento, ya que en l, adems del algoritmo
elegido, influye el tamao de la base de datos. Estas caractersticas han de
tenerse en cuenta a la hora de disear un sistema segn sea su utilidad.
2.2.3.
ALGORITMOS
Existen actualmente multitud de algoritmos y mtodos para el

reconocimiento
facial,
continuacin
se
describen
brevemente
sus
caractersticas y sus ventajas e inconvenientes para poder hacer una pequea

comparacin a priori; posteriormente se detallar su funcionamiento.
- Correlacin y FFT: Consiste en realizar la correlacin de la imagen
con la cara a reconocer con cada una de las imgenes de la base de datos. Al
ser est un proceso que requiere un elevado poder computacional, sobre todo
si se tiene un elevado nmero de pxeles por cara, se aprovechan las
propiedades de la fft para realizar la correlacin.
Csar Reyes Lpez
Pgina 14

Ventajas:
Algoritmo muy estudiado y fcil de implementar.
Desventajas: Algoritmo robusto para imgenes dispares pero muy

impreciso para rostros, donde las diferencias relativas entre imgenes son
pequeas.
- PCA y Eigenfaces: PCA (Principal Analysis Component) representa

una cara por un conjunto reducido de valores que representan caractersticas
de la imagen. Un pequeo nmero de imgenes sirve para describir la
variacin entre ellas. Las componentes principales son los denominados
Eigenfaces o autovectores de la matriz de covarianzas formada por las
imgenes de la base de datos. El reconocimiento se realiza mediante la
proyeccin de una nueva cara en el subespacio formado por los eigenfaces y
comparando su posicin con las posiciones de los rostros conocidos.
Ventajas:
Tiempo
de
cmputo
pequeo
elevado
discernimiento en condiciones ptimas (igual iluminacin, orientacin y posicin

para todos los rostros)
Desventajas: Muy dependiente de las condiciones de iluminacin,
posicin y orientacin de la cara en la imagen inicial.
- Basado en parmetros (LFA): Derivado de Eigenfaces, solventa el

problema de cambios en posturas, deformaciones de la cara,...
Se basa en caractersticas individuales de la cara.
Ventajas:
Adaptacin a cambios de expresin.
Desventajas: Computacionalmente costoso
- Basado en Redes Neuronales: Entrenamiento de una red neuronal

con las caractersticas faciales de una multitud de caras-ejemplo, incluyndose
cambios en la iluminacin, gestos, etc.
Csar Reyes Lpez
Pgina 15

Ventajas:
Buena exactitud.
Desventajas: Necesidad de entrenamiento previo, sensible a

variaciones y computacionalmente costoso.
- Basado en Plantillas: Se extraen regiones de las imgenes y se

almacenan en una base de datos, todas ellas como pertenecientes a una
imagen. Posteriormente con la imagen a reconocer, se comparan para cada
una y pxel a pxel las regiones almacenas.
Ventajas:
Preprocesamiento de la imagen simple.
Desventajas: La bsqueda en la base de datos y la comparacin

son costosas.
2.2.3.1.
Correlacin y FFT
Este mtodo de reconocimiento quizs pudiera entenderse como el ms

intuitivo de todos, ya que si se piensa en las imgenes de caras como en
seales, para saber cuanto se parecen unas a otras bastara con calcular la
correlacin y estipular un umbral de discernimiento.
La correlacin de una imagen I1 de tamao (X1,Y1) con otra I2 de
tamao (X2,Y2) es otra imagen IC de tamao (X1,Y1).
IC(x, y ) = Corr(I1,I2 ) (x, y )

= I1 (I2)'
X2 Y 2
= I1(i + x, j + y )I2(i, j)
(1)
(2)
(3)
i=1 J=1
con x = 1,,X1 e y = 1,, Y1.

(I2) es la imagen I2 rotada 180 y el smbolo * es el operador convolucin.
Definindose I1 de la forma I1(a,b) = 0 para todo a > X1 y b > Y1.
Csar Reyes Lpez
Pgina 16

La ecuacin (3) es una manera lenta de realizar la correlacin. Existen

tcnicas alternativas mucho ms rpidas, una de ellas se basa en la utilizacin
de la transformada discreta de Fourier (DFT).
Si se define:
If1= F(I1)
If2= F(I2)
IfC = F(IC)
Con F(I) la transformada discreta de Fourier de la imagen I.
Se tiene:
IfC = If1 (If 2)'
(4)
IfC(i, j) = If1(i, j) (If 2(i, j))
(5)
siendo x la transpuesta de x.
Puede observarse que ahora, el operador convolucin no son dos
sumatorios sino simplemente una multiplicacin en el dominio de Fourier, por
tanto para cada punto, ahora solo hay que calcular un producto.
La imagen deseada IC se haya sin ms que realizar la antitransformada
a IfC.
IC = F 1 (IfC)
(6)
Para calcular la transformada discreta de Fourier (DFT) se utiliza un

algoritmo llamado FFT (Fast Fourier Transform), transformada rpida de
Fourier, que calcula la transformada de Fourier de manera ms eficiente, con
un menor nmero de operaciones, por tanto, ms rpidamente y teniendo en
cuenta que para poder aplicar dicho algoritmo, las imgenes de entrada han de
tener un tamao mltiplo de 2.
A raz de lo anteriormente expuesto, se observa la simplicidad de este
mtodo de reconocimiento, para una imagen de entrada, se realiza su
Csar Reyes Lpez
Pgina 17

correlacin con cada una de las imgenes almacenadas en la base de datos y

si el valor supera un umbral establecido, se obtiene la correspondencia. Para
imgenes dispares, esto es, imgenes muy diferentes entre s como pudieran
ser por ejemplo frontales de coches y camiones, el sistema funciona
perfectamente, pero para imgenes faciales, donde las variaciones entre
individuos no es tan sustancial los valores de las correlaciones son todos muy
prximos entre si, lo que hace al sistema imposible discernir si una imagen
pertenece o se parece a alguna de la base de datos o no.
2.2.3.2.
PCA y Eigenfaces
Al ser este el algoritmo utilizado en el proyecto, se describe

detalladamente
su
funcionamiento
en
el
apartado
2.3.2.1
PCA
EIGENFACES, dentro del bloque de tcnicas empleadas.
2.2.3.3.
Basado en Parmetros (LFA)
Esta tcnica necesita un preprocesamiento de la imagen diferente a las

anteriores, el objetivo de este es deshacerse del ruido de alta intensidad en la
imagen, transformando la imagen de la cara de entrada en una imagen binaria
por medio de un detector adaptativo de bordes y luego extraer la textura de la
cara. Posteriormente, mediante el empleo del anlisis de caractersticas locales
se combinarn ambos, los bordes de la forma de la cara y la textura.
En general, una cara contiene cuatro rasgos principales, cejas, ojos,
nariz y boca. Para reducir el ruido y algunas zonas oscuras alrededor de estos
cuatro rasgos se emplea una operacin de deteccin de bordes a la imagen de
la cara de entrada. Esta operacin puede evitar caractersticas indeseadas de
una imagen como brillos, ruidos o reflexiones en los ojos.
La ventaja de usar bordes como una de las caractersticas de la imagen
es que estos proporcionan robustez frente a los cambios de iluminacin y
simplifican la representacin. Por tanto, la imagen de entrada es en primer
Csar Reyes Lpez
Pgina 18

lugar procesada con una deteccin morfolgica de bordes y el resultado es

convertido de una imagen en escala de grises a una imagen binaria, donde
solo se aprecian los bordes en negro sobre blanco. Un umbral fijo no trabaja
bien para convertir una imagen en escala de grises a una binaria. Esto es
debido al hecho de que el contraste en una imagen de bordes puede variar
significativamente. Una aproximacin es usar un umbral dinmico para cada
subbloque de la cara de la imagen de entrada mediante la consideracin de
intensidades de nivel de gris por encima del 15%, denominando a este umbral
calculado dinmicamente como T. Se asume que el histograma de cada
subbloque de la imagen de bordes es his(i), donde i = 0, 1, , 255. Luego T es
determinado como el mayor valor tal que satisfaga la siguiente ecuacin:
255
his(i) 0.15h w
i =T
donde h y w son el alto y el ancho de cada subbloque de una imagen de bordes

respectivamente.
Ilustracin 1: (a) y (c) imgenes faciales originales, (b) y (d) imgenes binarias de bordes.
El anlisis de caractersticas locales (LFA) define una serie de

topogrficas y locales semillas o kernels que son ptimamente comparadas y
emparejadas con el conjunto de entrada. Estas semillas estn derivadas de las
componentes principales, y consisten en una esferizacin de los coeficientes
PCA que ecualiza su varianza, seguida por una rotacin en el espacio de los
pxeles.
Se comienza con la matriz de ceros significativa formada por las
imgenes originales, X. La matriz X es la informacin de la textura de la imagen
Csar Reyes Lpez
Pgina 19

de entrenamiento seguida por la informacin de bordes. Despus se calculan

las componentes principales o eigenvectors P de acuerdo a S = PDPT. Si se
define una serie de kernels, K como K = PVPT donde
1
1
i = 1, , p
V = D 2 = diag

i
donde i son los eigenvalues de S. Las filas de K contienen los kernels. Los
kernels tienen espacialmente propiedades locales y son topogrficos en el
sentido de que estn indexados por localizaciones espaciales. La matriz semilla
K transforma X a la salida LFA O = KXT. La matriz V es la raz cuadrada inversa
de la matriz de covarianza de los coeficientes principales. Esta transformada
esfera los componentes principales (normalizada su varianza de salida a la
unidad) y minimiza la correlacin en la salida LFA. Otra manera de interpretar
la salida LFA O es que esta es la reconstruccin de la imagen usando los
coeficientes PCA esferizados, O = P(VPTXT).
LFA genera una representacin n-dimensional, donde n es el nmero de
pxeles de la imagen. Desde que se tienen n salidas descritas por p << n
variables linealmente independientes, existen correlaciones independientes en
la salida. Existen algoritmos para reducir la dimensionalidad de la
representacin mediante la eleccin de un subconjunto M de salidas que sean
lo ms incorreladas posible. El algoritmo de sparsification es un algoritmo
iterativo basado en una regresin lineal mltiple. En cada iteracin, el punto de
salida que sea peor predicho, mediante la regresin lineal mltiple para los
puntos de M, se aade a M. Debido a las propiedades topogrficas de los
kernels, la seleccin de los puntos de salida es equivalente a la seleccin de
los kernels para la representacin. El algoritmo de sparsification selecciona
diferentes series de kernels, M, por cada imagen problemtica a la hora del
reconocimiento.
A la hora de hacer la representacin ms susceptible al
reconocimiento, se selecciona un simple juego de M kernels para todas la

imgenes. En cada iteracin, el kernel correspondiente al pxel con el ms
significativo error de reconstruccin para todas las imgenes es aadido a M.
En cada paso, el kernel aadido a M es elegido como el kernel correspondiente
a la localizacin
Csar Reyes Lpez
Pgina 20

arg max O O rec
donde Orec en una reconstruccin de la salida completa O, usando un predictor

lineal para el subconjunto de salidas O generadas desde los kernels en M. El
predictor lineal es de la forma Y = X donde Y = Orec, es el vector de los
parmetros de la regresin, y X = O(M,N). Donde, O(M,N) denota al
subconjunto de O correspondiente a los puntos en M para todas las N
imgenes. es calculada de la siguiente manera:
YX
(O res ) T O( M , N )
=
=
( X T X ) O( M , N ) T O( M , N )
Esta ecuacin puede expresarse tambin en trminos de la matriz de

correlacin de las salidas, C = OTO.
= C ( M , N )C ( M , M ) 1
La condicin de fin se produce cuando M = N .
2.2.3.4.
Basado en Redes Neuronales
Las Redes Neuronales surgen en el contexto de computacin evolutiva y

cognitiva, lgica difusa, razonamiento aproximado, teora del caos, teora del
aprendizaje, y su funcionamiento se basa en la emulacin de los sistemas
nerviosos biolgicos.
Excepto en las tareas basadas en el clculo aritmtico simple, en la
actualidad, el cerebro humano es superior a cualquier computador.
Procesamiento de imgenes, voz, datos inexactos o con ruido, lenguaje
natural, prediccin, control,. El cerebro se comporta como un sistema robusto
cuyo funcionamiento no se altera ante fallos poco importantes, flexible, se
adapta con facilidad a un entorno cambiante, capaz de tratar con informacin
ambigua o incompleta, es pequeo, compacto y consume poca potencia.
Csar Reyes Lpez
Pgina 21

Una Red Neuronal, debe tener caractersticas que se asemejen a las de

un sistema nervioso biolgico.
La informacin se almacena en las interconexiones, es distribuida y
redundante y se direcciona por contenido. Las operaciones se realizan en
paralelo, de manera asncrona. Su funcionamiento se basa en el aprendizaje y
no en la algoritmizacin. Aplican razonamiento inductivo: dados una serie de
patrones de entrenamiento aprenden los pasos a ejecutar. Son tolerantes a
fallos porque la informacin es distribuida, las operaciones son colectivas y la
conectividad de los elementos puede adaptarse al problema.
Las Redes Neuronales estn formadas por neuronas y ests a la vez se
agrupan en capas.
Una de las caractersticas fundamentales es el aprendizaje o
entrenamiento al que hay que someter a una red neuronal antes de poder
aplicarla a la resolucin de algn tipo de problema.
Ilustracin 2: Ejemplos de redes neuronales
Csar Reyes Lpez
Pgina 22

El reconocimiento facial desde el punto de vista de redes neuronales no

deja de ser un caso especial de reconocimiento de patrones y clasificacin. La
red neuronal es entrenada a tal efecto mediante el almacenamiento de un
conjunto de patrones, en este caso, caras y caractersticas de caras de
individuos. Cuando se le presenta a la entrada una nueva, distorsionada, o con
ruido, debe proporcionar el original o la ms parecida.
Ilustracin 3: Ejemplo de Red Neuronal para Reconocimiento Facial
Debido a que la informacin es distribuida y se trabaja de forma

colectiva, si el proceso de entrenamiento ha sido lo suficientemente bueno,
tenindose en cuenta cambios en la iluminacin, posicin, etc, el resultado
es ptimo. Todo ello a costa de un elevado coste computacional si se realiza en
computadores digitales convencionales donde solo se dispone de un
microprocesador relativamente complejo que trabaja de manera secuencial,
donde habra que emular el paralelismo.
2.2.3.5.
Basado en Plantillas
Este mtodo est basado en la divisin de la imagen de la cara en

regiones o zonas caractersticas y almacenar estas en una base de datos,
aplicando esto a todas las caras del proceso de entrenamiento o aprendizaje
Csar Reyes Lpez
Pgina 23

inicial. El siguiente paso es sencillo: para una nueva imagen se comparan las
regiones de sta con las almacenadas en la base de datos y se extraen
conclusiones.
El preprocesamiento de la imagen debe constar de mtodos de
deteccin de zonas significativas, como son la zona de la boca, nariz y ojos,
para su posterior almacenaje, para ello puede utilizarse el mtodo de la
correlacin explicado anteriormente. Pueden tenerse mscaras estndar de
ojos, por ejemplo, que al correlacionarlas con las imgenes, nos den las zonas
de las mismas donde se encuentran los ojos de la cara, y as para otras zonas
con otras mscaras.
Ilustracin 4: Ejemplo de Reconocimiento Facial por plantillas
pesar
de
ser
un
sistema
sencillo
conceptualmente,
computacionalmente es muy costoso, ya que la informacin almacenada en la

base de datos y por tanto la que hay que comparar es muy elevada, para una
elevada precisin habra que tener almacenadas muchas imgenes con sus
respectivas regiones.
Csar Reyes Lpez
Pgina 24

2.3. TCNICAS EMPLEADAS

La eleccin de las siguientes tcnicas, tanto la de deteccin de caras
como la de reconocimiento facial basada en el uso de eigenfaces ha venido
determinada en gran medida por el uso de las libreras OpenCV (Intel Open
Source Computer Vision Library) de Intel, donde muchos de los algoritmos
necesarios para el desarrollo de dichas tcnicas estaban implementados, se
opt por continuar y aprovechar el trabajo realizado hasta el momento con
estas libreras,
independientemente de las ventajas e inconvenientes que
dichas tcnicas presentan frente al resto.
2.3.1.
DETECCIN DE CARAS
Aunque este proceso en s podra considerarse como no necesario, si se

usan eigenfaces (ver apartado 2.3.2.1) en determinadas condiciones,
condiciones de iluminacin controladas e invariantes, y caras dentro de la
imagen que ocupen la misma posicin y tamao, se ha optado por implementar
un mtodo de deteccin de caras dentro de una imagen para flexibilizar el
preprocesamiento de la imagen que necesitan los mtodos de reconocimiento
facial.
La deteccin de caras es necesaria en este proyecto puesto que se trata
de un sistema dinmico, donde las imgenes de partida no estn tomadas en
un laboratorio en condiciones ideales sino propiciadas por acciones de usuarios
en tiempos no determinados, ms concretamente con la pulsacin de una tecla
en el momento que el usuario quiera fotografiarse, tanto para almacenar su
rostro dentro de la base de datos como para comprobar su permanencia a la
misma. Por tanto, el sistema debera ser capaz de descartar, suponiendo
condiciones de iluminacin constantes, aquellas imgenes en las que la cara
del usuario no cumpliese con una serie de criterios establecidos a priori,
orientacin, tamao, posicin, etcDichos criterios deberan cumplirse en
todas y cada una de las caras almacenadas en la base de datos.
Csar Reyes Lpez
Pgina 25

En consecuencia, el proceso de deteccin de caras no es ms que una

interfaz que presenta al mdulo de reconocimiento facial imgenes de caras
homogneas, entendindose por imgenes homogneas, imgenes que
cumplen los criterios establecidos a priori para el ptimo funcionamiento en la
fase de reconocimiento facial.
El algoritmo de deteccin de caras est basado en una funcin que
busca regiones rectangulares dentro de una imagen, regiones que contengan
objetos que con una alta probabilidad se parezcan a otros de un conjunto de
entrenamiento, devolviendo la regin rectangular de la imagen donde se han
encontrado. La funcin escanea varias veces la imagen y con diferentes
escalas para encontrar objetos parecidos pero de diferentes tamaos. Por
tanto, para detectar caras, nicamente hay que pasarle a la funcin el conjunto
de caras de entrenamiento con las caractersticas deseadas para que las caras
detectadas sean parecidas a estas.
Una vez que se tiene la porcin de imagen de entrada en la que se
encuentra la cara deseada, aplicando un proceso de escalado, se estandariza
el tamao de dicho rectngulo a uno de referencia para que todas las imgenes
de caras a tratar, tanto para el proceso de reconocimiento como para el de
inclusin en la base de datos, tengan el mismo tamao.
2.3.2.
En un principio, la tcnica elegida fue la realizacin de la correlacin de

las imgenes usando para ello la FFT, tcnica que se ha explicado en el
apartado 2.2.3.2. En el primer apartado que sigue, Trabajo Previo: correlacin y
FFT, se muestra un ejemplo del por qu se desisti en el uso de dicha tcnica y
se enfocaron los esfuerzos al uso de eigenfaces, siguiente apartado.
Csar Reyes Lpez
Pgina 26

2.3.2.1.
TRABAJO PREVIO: correlacin y FFT
Para el desarrollo de la aplicacin de est tcnica, se comenz con la

utilizacin del entorno de programacin Matlab, pues existen funciones ya
implementadas en dicho software que calculan la transformada FFT y su
inversa, pues como se ha explicado con anterioridad, la correlacin de dos
imgenes puede implementarse de manera ms eficiente como el producto de
dos FFTs y una antitransformacin. Posteriormente, si los resultados hubiesen
sido satisfactorios se hubiesen diseado las correspondientes funciones
necesarias utilizando el lenguaje C++, para poder utilizarlas con las funciones
de librera OpenCV y el resto de aplicaciones implementadas.
A continuacin se muestran algunos de los experimentos y estudios
realizados.
En primer lugar se utilizaron tres imgenes en escala de grises de caras
diferentes, se utiliz una como patrn y se correlacion con las otras dos
restantes y consigo misma, el resultado fue el siguiente:
Csar Reyes Lpez
Pgina 27

Ilustracin 5: Ejemplo de correlacin de caras. Caras y FFT
Se observa como la tercera imagen para los dos primeros casos es

prcticamente idntica, y para el caso en el que se calcula la correlacin de
una cara consigo misma, el nivel de gris desciende levemente. Podra entonces
pensarse en definir un umbral segn el cual, la correlacin de las imgenes que
presentara el menor nivel de gris y estuviera por debajo de dicho umbral sera
la cara ms parecida a la del usuario. Sin embargo, esta pequea diferencia
entre caras iguales o diferentes se hace mucho menos notable cuando el
nmero de fotos se intensifica y aparecen caras parecidas unas a otras, incluso
para una misma cara de usuario pero ligeramente diferente, la probabilidad de
error aumenta significativamente, pues nunca se podran tener para comparar
dos fotos idnticas, una almacenada y la otra realizada en el momento de la
deteccin.
Tomando ahora imgenes dispares como por ejemplo frontales de
coches y camiones, se aprecia como los niveles de gris se distancian mucho de
un caso a otro.
Csar Reyes Lpez
Pgina 28

Ilustracin 6: Ejemplo de correlacin de frontales de coches y camiones
Con imgenes dispares, el mtodo de la correlacin funciona

correctamente. Por ejemplo, si se tuviera una imagen con multitud de vehculos
de frente, podra correlacionarse a modo de mscara la imagen de un tipo
determinado de frontal, y las zonas de la imagen que aparecieran con niveles
de grises prximos al blanco, como en el ejemplo anterior, podran clasificarse
de un determinado tipo, frente a las que aparezcan prximas al negro y del
mismo modo con diferentes frontales.
Por tanto, este mtodo de comparacin de imgenes es bueno para
clasificar objetos, como pudiera ser el caso anterior, pero no para distinguir
objetos parecidos unos a otros donde las diferencias no son significativas y la
probabilidad de equivocarse sera elevada.
2.3.2.2.
PCA Y EIGENFACES
Como se ha comentado con anterioridad, matemticamente hablando, lo

que se desea es encontrar las componentes principales de una distribucin de
caras o lo que a partir de este apartado se le denominar como eigenvectors
de la matriz de covarianza de un conjunto de imgenes de caras, tratando a
una imagen como un vector en un espacio multidimensional. Los eigenvectors
son ordenados, cada uno de acuerdo a diferentes cantidades segn la
variacin entre las imgenes de caras.
Estos eigenvectors pueden ser interpretados como un conjunto de
caractersticas que juntas, caractericen la variacin entre las imgenes de las
caras. Cara localizacin de una imagen contribuye en mayor o menor medida a
Csar Reyes Lpez
Pgina 29

cada eigenvector, por lo que puede mostrarse el eigenvector como una

representacin fantasmal de una cara, a la que se le denomina eigenface.
Cada eigenface se desva del gris uniforme donde alguna caracterstica facial
difiere entre el conjunto de caras de entrenamiento, las eigenfaces son por
tanto una especie de mapa de las variaciones entre imgenes.
Cada cara individual puede ser representada exactamente en trminos
de una combinacin lineal de las eigenfaces. Cada cara tambin puede ser
aproximada usando solamente las mejores eigenfaces las que tienen
mayores eigenvalues, y por tanto las que cuentan con una mayor variacin
dentro del conjunto de las imgenes de las caras -. Las M mejores eigenfaces
conforman un subespacio M-dimensional espacio de las caras de todas las
posibles imgenes.
Sirovich y Kirby (1987) fueron los primeros en desarrollar una tcnica
basada en el uso de eigenfaces para una representacin eficiente de imgenes
de caras, usando la descomposicin en componentes principales. Comenzaron
con un conjunto de imgenes originales de caras, posteriormente calcularon un
sistema de coordenadas para la compresin de imgenes, donde cada
coordenada es en realidad una imagen, a la que denominaron eigenpicture.
Argumentaron que, como mnimo, en principio, cualquier coleccin de
imgenes de caras poda ser reconstruida aproximadamente mediante el
almacenamiento de una pequea coleccin de pesos por cada cara y un
pequeo conjunto de imgenes estndar ( las eigenpictures ). Los pesos que
describen cada cara son encontrados mediante la proyeccin de la imagen de
la cara sobre cada eigenpicture.
Segn esto, si una multitud de imgenes de caras pueden ser
reconstruidas mediante clculos ponderados de una pequea coleccin de
caractersticas singulares o eigenpictures, un mtodo eficiente para aprender y
reconocer caras podra ser la acumulacin de caractersticas singulares
mediante una fase de entrenamiento o experiencia y reconocer caras
particulares mediante la comparacin de los pesos caractersticos necesarios
para aproximar o reconstruirlas con los pesos asociados a los conocidos
individuales. Cada individuo, por tanto, estar caracterizado por el pequeo
Csar Reyes Lpez
Pgina 30

conjunto de pesos caractersticos o eigenpicture necesarios para describirlo y

reconstruirlo, una manera extremadamente compacta de representacin y
comparacin de imgenes.
Este mtodo de reconocimiento facial, utilizacin de eigenfaces, necesita
de una serie de operaciones iniciales, tales como:
1.-
Adquisicin de una serie de imgenes de caras iniciales; proceso
de entrenamiento o de adquisicin de experiencia.

2.-
Clculo de los eigenfaces del conjunto de entrenamiento,
almacenando nicamente las M imgenes que correspondan con los

eigenvalues mayores. Estas M imgenes definen el espacio de caras. Si se
aaden nuevas caras al sistema, las eigenfaces deben ser actualizadas o

recalculadas.
3.-
Clculo de la correspondiente distribucin en el espacio de pesos
M-dimensional para cada individuo conocido mediante la proyeccin de su cara

sobre el espacio de caras.
Estas operaciones pueden llevarse a cabo cada vez, pero hacen al
sistema computacionalmente ms costoso.
Teniendo inicializado el sistema, para reconocer nuevas caras hay que
realizar los siguientes pasos:
1.-
Clculo de un conjunto de pesos basados en la imagen de
entrada y las M-eigenfaces mediante la proyeccin de la imagen de entrada

sobre cada una de las eigenfaces.
2.-
Determinar si la imagen de la cara pertenece o no al conjunto
viendo lo cercana que est al espacio de las caras.

3.-
Opcionalmente, podran actualizarse las eigenfaces y/o los pesos
patrones, y si la misma cara desconocida es vista varias veces, podra aadirse

esta a la base de caras conocidas creada en el proceso de entrenamiento.
Csar Reyes Lpez
Pgina 31

CLCULO DE LAS EIGENFACES

Se define una imagen I(x,y) como una matriz bidimensional de N filas y
N columnas, cuyos valores de intensidad varen entre 0 y 255 (8 bits), imagen
en escala de grises. Tambin puede ser considerada como un vector de
dimensin N2, por lo que una imagen tpica de tamao 128 por 128 puede
convertirse en un vector de dimensin 16324 o, equivalentemente, en un punto
en un espacio de 16324 dimensiones. Un conjunto de imgenes, se mapean a
una coleccin de puntos en este espacio enorme.
Las imgenes de caras, an siendo similares en una configuracin
general, no estarn aleatoriamente distribuidas en este enorme espacio de
imgenes y de esta manera pueden ser descritas mediante un relativamente
pequeo
subespacio
dimensional.
La
idea
principal
del
Anlisis
de
Componentes Principales o PCA es encontrar los vectores que mejor describan

la distribucin de las imgenes de caras dentro de la totalidad del espacio de
imgenes. Estos vectores definen el subespacio de imgenes de caras, al que
se denomina face space, espacio de las caras. Cada vector es de longitud N2,
describe a una imagen de tamao N x N, y es una combinacin lineal de la
imagen de una cara original. Debido a que estos vectores son los eigenvectors
de la matriz de covarianza correspondiente a la imagen de la cara original y a
que aparentemente se parezcan a dicha cara, se les denomina eigenfaces.
A continuacin se muestran un conjunto de caras y sus correspondientes
eigenfaces.
Csar Reyes Lpez
Pgina 32

Ilustracin 7: Ejemplo de base de datos de caras (Fuente FERET)
Ilustracin 8: Eigenfaces de las caras anteriores
Definiendo al conjunto de imgenes de caras de entrenamiento como 1,

2, 3, , M, la cara promedio de este conjunto viene dada por =
1 M
n .
M n=1
Cada cara difiere de la media segn el vector i = i .

Este conjunto de grandes vectores est sujeto al anlisis de
componentes principales, el cual busca una serie de M vectores ortonormales
un que mejor describan la distribucin de los datos. El k-simo vector, uk, es
elegido de tal forma que
Csar Reyes Lpez
Pgina 33

k =
1 M T
uk n
M n=1
sea mximo, sujeto a

1 l = k
u lT u k = k
0 e.o.c.
Los vectores uk y los escalares k, son los eigenvectors y eigenvalues

respectivamente de la matriz de covarianza
C=
1 M
n nT = AA T
M n=1
donde A es la matriz A = [ 1 2 ... M ] . La matriz C es de dimensin N2 x

N2.
La determinacin de los N2 eigenvectors y eigenvalues es un proceso
computacionalmente costoso para el tamao tpico de las imgenes con las
que se trabaja.
Si el nmero de puntos de datos en el espacio de imgenes es menor
que la dimensin del espacio ( M < N2 ), habr solamente M - 1, menor que N2,
eigenvectors significativos ( los restantes eigenvectors estarn asociados a los
eigenvalues de cero). Puede resolverse el sistema para los eigenvectors N2-
dimensionales resolviendo primero para los eigenvectors de una matriz M x M y

luego realizando las apropiadas combinaciones lineales de las imgenes de las
caras i. Considerando los eigenvectors vi de AAT, tales que:
AA T v i = i v i
Premultiplicando ambos miembros por A, se tiene:
AA T Av i = i Av i
donde puede observarse que Avi son los eigenvectors de C = AAT.
Csar Reyes Lpez
Pgina 34

Se construye la matriz L = ATA, donde L mn = mT n y se encuentran los

M eigenvectors, vk de L. Estos vectores determinan la combinacin lineal de las
M imgenes del conjunto de caras de entrenamiento para formar las eigenfaces
ul,
M
u l = v lk k l = 1, , M
k =1
El proceso de reconocimiento es el siguiente: una nueva imagen de una

cara de entrada (), es transformada a sus componentes eigenfaces
(proyectada dentro del espacio de caras) mediante una simple operacin:
k = u kT ( ) para k = 1, M, obtenindose un conjunto de pesos que
conforman el vector T = [1 2 ... M ] que describe la contribucin de
cada eigenface en la representacin de la imagen de entrada o de otra manera,
cunto de cerca (parecido) est cada eigenface de la imagen de entrada. Por
tanto, este vector puede ser usado como un modelo estndar dentro de un
algoritmo de reconocimiento sin ms que evaluar una distancia entre vectores y
mediante un umbral de discernimiento determinar si una imagen de una cara
puede considerarse perteneciente al espacio de caras de entrenamiento o no.
Este valor sera el que minimice la distancia eucldea:
k2 = ( k )
donde k es el vector que describe la k-sima cara.
RESUMEN
Resumiendo y sintetizando, el proceso de reconocimiento facial
mediante el uso de la descomposicin en valores principales (PCA) y
Eigenfaces consta de los siguientes pasos:
Csar Reyes Lpez
Pgina 35

1.-
Almacenar un conjunto de imgenes de entrenamiento de
diferentes personas, pudindose tener subconjuntos de imgenes para cada

persona que contengan diferentes posturas, condiciones de iluminacin, etc.
2.-
Crear una matriz formada por la nueva imagen de entrada y las ya
almacenadas en la base de datos. Mediante el proceso arriba descrito, se

calculan los eigenvectors mediante la matriz de covarianza.
3.-
Una vez obtenidos los vectores caractersticos se comparan las
distancias entre el vector que representa a la imagen original con el resto.

4.-
Establecido un umbral de discernimiento a priori, si el menor valor
del paso anterior es menor que este umbral, la imagen de la cara de entrada es
considerada como conocida, si es mayor, se considera desconocida.
De aqu se desprende que los valores de las distancias dependen en

cierta medida del tamao de la base de datos, puesto que la matriz de
covarianza y los vectores caractersticos son calculados a partir de la matriz
formada por la imagen de entrada y las ya almacenadas, por lo que el umbral
de discernimiento ha de ser dinmico y adaptarse segn la variacin de las
distancias entre caras, o lo que es lo mismo, segn el tamao de la base de
datos que almacena las imgenes de las caras.
2.3.3.
REALCE MEDIANTE IGUALACIN DE
HISTOGRAMA
Un histograma de una imagen en escala de grises, no es ms que una
funcin discreta, en la que cada valor representa el nmero de puntos con el
mismo nivel de gris, sobre el nmero total de puntos de una imagen.
Para realzar una imagen mediante el uso de su histograma, se intenta
expandir en la medida que se pueda las zonas de dicho histograma que
presenten elevados valores y prximos entre si, igualacin de histograma, lo
Csar Reyes Lpez
Pgina 36

que significa, ampliar el nmero de niveles de gris de la imagen en cuestin,

implica tener una mayor precisin en los detalles de la imagen. Para ello, se
construye una funcin que sea la suma para cada punto de las probabilidades
de los niveles de gris de la imagen, esta funcin es no multievaluada y
montona creciente, realizando la transformada inversa y aplicndosela a la
imagen original se tendr la imagen realzada, el nuevo histograma se ver
expandido con respecto al original.
A continuacin y a modo de ejemplo ilustrativo se muestra el
procedimiento de realce mediante el uso de la igualacin de histograma para la
imagen de una cara.
Ilustracin 9: Cara original e histograma
Puede observarse como la cara de la imagen presenta muchos valores

prximos al negro, en el histograma, valores elevados y prximos, cercanos al
cero (negro). Se pretender por tanto que dichos valores se separen entre s
ocupando una mayor zona entre el 0 y el 1 (negro y blanco).
Una vez obtenido el histograma de la imagen de la cara original, si se
profundiza un poco ms en el significado del histograma, si se divide cada
componente del mismo por el nmero total de pxeles que tiene la imagen, se
obtiene una funcin de probabilidad (fdp) de cierto tono de gris en la imagen.
Puede por tanto hallarse la funcin de distribucin (FD) de esta fdp, sin ms
Csar Reyes Lpez
Pgina 37

que sumar para cada una de las componentes del eje horizontal del histograma
el valor de la componente vertical ms los valores de las componentes
anteriores, se tiene entonces una curva como la siguiente:
Ilustracin 10: Funcin de Distribucin
Aplicando ahora la transformada inversa de esta funcin a los pxeles de

la imagen anterior se obtiene el siguiente resultado:
Ilustracin 11: Cara realzada e histograma
Donde puede observarse como el histograma de la imagen de la cara

obtenida aplicando dicha transformacin se ha expandido en torno a los
Csar Reyes Lpez
Pgina 38

lugares donde existan en un principio muchos puntos de igual valor y prximos

entre s.
Con la ecualizacin lo se consigue es obtener un histograma ms
uniforme, distribuyndose las gamas de tonos que ms aparecen por todo el
histograma. Esto logra un aumento del contraste en ciertas zonas de la imagen,
resaltando detalles que antes no se vean. De hecho, si en vez de trabajar con
variables discretas lo hiciramos con variables continuas, lo que obtendramos
sera una seal de salida con su histograma (continuo) plano.
Con una simple modificacin del contraste, adems de mejores
resultados, la diferencia es que tal y como est construida la funcin de
transferencia, no se pierde informacin y por tanto siempre se podra recuperar
la imagen original. Se podra decir que lo que se obtiene con la igualacin es
un aumento de contraste en las zonas de la imagen ms necesarias.
Csar Reyes Lpez
Pgina 39

3. COMPONENTES DEL SISTEMA

3.1. ESTRUCTURA
En este apartado se describen los diferentes componentes que
conforman el sistema desarrollado de reconocimiento facial, tanto a nivel fsico,
entorno de trabajo y hardware como software.
En la primera seccin se describen las caractersticas del entorno de
trabajo, comenzando con una pequea discusin sobre las fuentes de
iluminacin, directa, arbitraria y la utilizada. Luego se pasa a definir el entorno
de trabajo en s y sus peculiaridades. Posteriormente se describe el hardware
utilizado, tanto el tipo de cmara web como el equipo informtico del que se ha
dispuesto.
En la segunda y ltima seccin se describe el entorno de programacin
en el que se ha desarrollado el proyecto, tanto las libreras utilizadas (OpenCV)
como el paquete del software para la programacin del mismo (Visual Studio
6.0).
Csar Reyes Lpez
Pgina 40

3.2. ENTORNO DE TRABAJO

3.2.1.
FUENTE DE ILUMINACIN
En todo proceso de visin artificial es fundamental la eleccin del ms

adecuado tipo de fuente de iluminacin, ya que la obtencin de resultados
satisfactorios depender en gran medida de ello. Puede disminuirse de manera
significativa efectos indeseados como imgenes con un bajo contraste, brillos,
sombras y detalles espreos. Un sistema de luces apropiado simplifica la
imagen del objeto a estudiar aportando informacin de mayor calidad para la
deteccin y extraccin del mismo, haciendo innecesaria la aplicacin de
algoritmos de correccin en el proceso de visin.
El trabajar en entornos poco estructurados dificulta la aplicacin de los
procesos y tcnicas de visin, por lo que se intenta que las condiciones de
iluminacin permanezcan invariantes el mayor tiempo posible.
En un entorno de trabajo pueden diferenciarse dos tipos de fuentes de
iluminacin:
Fuente de iluminacin directa
Fuente de iluminacin arbitraria
3.2.1.1.
Fuente de iluminacin directa
Si se tiene una fuente de iluminacin directa, la luz incide directamente

sobre la cara del usuario intentndose as reducir al mximo los efectos de
sombra puesto que se mejora sensiblemente el contraste de la imagen. Sin
embargo aparecen otros problemas como brillos y zonas oscuras indeseadas si
el foco de luz no se encuentra en posicin y orientacin cercana a la cmara
web de captura o si el plano de la cara del usuario no est completamente
perpendicular al haz de luz del foco emisor. Por tanto, puede falsearse el
proceso de captura de imgenes. Adems hay que tener en cuenta que un foco
Csar Reyes Lpez
Pgina 41

de luz apuntando directamente sobre la cara del usuario resulta molesto,

disminuyendo el grado de aceptacin del sistema de reconocimiento facial.
3.2.1.2.
Fuente de iluminacin arbitraria
Generalmente, la iluminacin arbitraria del entorno de trabajo no suele

ser recomendable en procesos de visin por computador ya que las imgenes
obtenidas presentan un bajo contraste y un nivel de sombras inadecuado. Las
imgenes obtenidas, ms si se trabaja en exteriores, pueden variar
enormemente de una a otra hora del da, dificultando tanto el proceso de
captacin como el de reconocimiento ya que influyen tanto factores climticos
como otras fuentes de iluminacin no naturales.
3.2.1.3.
Iluminacin del entorno de trabajo
Vistas la particularidades de los diferentes tipos de iluminacin y

teniendo en cuenta que una de las caractersticas iniciales del proyecto es que
se asuma que las condiciones de iluminacin iban a ser constantes, para la
iluminacin del entorno de trabajo se ha elegido una mezcla de ambos tipos de
iluminacin, es decir, se cuenta con diferentes focos de luz directa, pero no se
prescinde de la iluminacin indirecta y arbitraria, ya sea natural o artificial,
procurndose sin embargo que la zona donde el usuario se establezca para
que se le capture una imagen de una cara tenga una variabilidad de
iluminacin prcticamente nula al igual que el fondo.
3.2.2.
ENTORNO ESTRUCTURADO
Este sistema de reconocimiento facial, y en particular la parte de

deteccin de la cara de usuario, ha sido diseado para trabajar en un entorno
mnimamente no estructurado, es decir, a la condicin de invariabilidad de la
iluminacin se suma la invariabilidad del entorno. Si la iluminacin es uniforme
Csar Reyes Lpez
Pgina 42

y constante, el fondo que pueda aparecer en la imagen capturada de la cara

del usuario se ver tambin constante y por tanto no afectar al resultado.
Existen sin embargo otros parmetros que s interfieren ms en el sistema.
- Distancia de la cara del usuario a la cmara. Para personas de distintas
edades y estaturas la distancia de la cara a la cmara puede verse alterada
significativamente, por lo que ser misin del software de extraccin y
normalizacin de la cara hacer que este efecto sea inapreciable.
- Posicin variable del plano de la cara del sujeto respecto del plano de
la cmara, pudindose tener por tanto diferentes orientaciones de una misma
cara de usuario e incluso no llegar a detectar una cara en una imagen.
Sin embargo, la robustez del sistema diseado hace posible que
pequeas variaciones de todas ests caractersticas del y en el entorno de
trabajo no influyan en los resultados.
3.2.3.
CMARA WEB
Para la obtencin de las imgenes se ha utilizado una cmara web,

puesto que era uno de los requisitos iniciales del proyecto.
Sus caractersticas son las siguientes:
Construccin:
Creative WebCam Instant

Conexin:
USB
Sensor:
Sensor de imgenes CMOS CIF

Resolucin de video:
Hasta 352 x 288 pxeles
Csar Reyes Lpez
Pgina 43

Resolucin de imagen, en modo esttico:
Hasta 352 x 288 pxeles

Hasta 640 x 480 pxeles con mejora por software
Formatos de video:
RGB24
I420
Control de exposicin:
Automtico
Balance de blancos:
Automtico
Campo de visin:
50 grados 5% (diagonal)
Rango de enfoque:
Desde 15 centmetros ( 6 pulgadas ) al infinito

Compatibilidad de puerto:
Universal Serial Bus (USB) 1.1

Compatibilidad de software:
Controlador TWAIN, de video para Windows, WDM MiniDriver

para DirectShow y controlador de Still Image ( STI ) que se ejecuta en Windows
XP, Windows 2000, Windows Me y Windows 98 SE.
Csar Reyes Lpez
Pgina 44

3.2.4.
EQUIPO INFORMTICO
Para la instalacin de las libreras y software necesario para el desarrollo

del proyecto se ha utilizado el siguiente equipo informtico:
Procesador:
AMD Athlon 1.40 GHz
Memoria:
512 Mb RAM DDR (266 MHz)
Tarjeta Grfica: Winfast GForce2 MX 64 Mb

Monitor:
Proview 17
3.3. ENTORNO DE PROGRAMACIN

3.3.1.
OPENCV
OpenCV, Open Source Computer Vision Library para arquitectura Intel,

es una librera cuyo principal objetivo es la visin por computador en tiempo
real, como por ejemplo, HCI (Human-Computer Interaction), interaccin
computador-humano, identificacin de objetos, segmentacin y reconocimiento,
reconocimiento facial, reconocimiento gestual, ajustes de movimientos,
comprensin de movimientos, SFM (Structure From Motion) y robtica mvil.
La librera OpenCV es una coleccin de funciones de alto rendimiento
para operaciones con imgenes, implementa una gran variedad de
aplicaciones para interpretacin y procesado de imgenes. Es compatible con
IPL (Intel Image Processing Library), librera que implementa operaciones a
bajo nivel en imgenes digitales. A pesar de que posee algoritmos tales como
binarizacin, filtrado, estadsticas de imagen o procesado piramidal, OpenCV
es principalmente una librera de algoritmos implementados de alto nivel para
tcnicas de calibracin, calibracin de cmaras, deteccin de caractersticas y
anlisis de formas y movimientos, reconstruccin 3D, segmentacin y
reconocimiento de objetos.
Csar Reyes Lpez
Pgina 45

La principal caracterstica de esta librera es la funcionalidad y calidad

con la que ha sido desarrollada. Los algoritmos estn basados en estructuras
de datos altamente flexibles y dinmicas emparejadas con las estructuras de
datos de IPL.
Las funciones y clases que componen la librera OpenCV han sido
desarrolladas en C y C++, por lo que para su uso es necesario tener instalado
en el ordenador algn compilador y editor de estos lenguajes como por ejemplo
Microsoft Visual Studio 6.0, Microsoft Visual Studio .NET 2003 o Borland C++
BuilderX.
Una de las ventajas de ser una librera de cdigo abierto es la aparicin
de comunidades dedicadas a compartir y ayudar en su uso, desarrollo y
actualizacin, sobre todo en el entorno de los ordenadores personales y
electrnica de consumo.
3.3.2.
MICROSOFT VISUAL C++ 6.0
El uso de Microsoft Visual C++ 6.0 viene impuesto por el hecho de

utilizar las libreras OpenCV desarrolladas en C y C++.
Microsoft Visual C++ 6.0 se incluye dentro del paquete Microsoft Visual
Studio 6.0, proporciona una herramienta potente para la creacin de programas
tanto en C como en C++ y una gran versatilidad de uso y depuracin.
Csar Reyes Lpez
Pgina 46

4. IMPLEMENTACIN
4.1. ESTRUCTURA
En este apartado se describe detalladamente como se ha implementado
el sistema de reconocimiento facial, desde su diseo, hasta los resultados de
su funcionamiento.
Dentro del bloque de DISEO, en una primera seccin se muestran
los diagramas de flujo de la funcin o programa principal y del mdulo
compara, el ms importante del sistema de reconocimiento facial diseado.
En la segunda seccin se detalla la estructura interna del sistema, los
mdulos principales en los que se divide y una descripcin de los mismos.
La tercera seccin contiene la descripcin de todas las funciones
utilizadas para el diseo e implementacin del sistema de reconocimiento
facial, tanto funciones de librera de OpenCV, como las diseadas
exclusivamente para el sistema, funciones propias. Las funciones de librera de
C++ utilizadas no son descritas por no ser relevantes.
Csar Reyes Lpez
Pgina 47

Las dos ltimas secciones muestran respectivamente el funcionamiento

general del sistema, con ejemplos de su utilizacin y los resultados obtenidos
de la misma.
El siguiente bloque es el de FUNCIONAMIENTO, donde se describe de
forma detallada y grfica el manejo y funcionamiento del programa.
Los dos ltimos grandes bloques corresponden a CRITERIOS PARA EL
RECONOCIMIENTO, donde se explican los criterios que deben cumplirse para
que un usuario sea reconocido (dentro de la funcin compara), una vez
comparada su cara con las de la base de datos, y RESULTADOS, donde se
muestran diferentes resultados obtenidos en cuanto a tiempo de cmputo y
fiabilidad en los reconocimientos.
Dentro del apartado CRITERIOS PARA EL RECONOCIMIENTO, se
encuentra COMPARA. Realce y Eigenfaces que muestra un ejemplo del
trabajo que realiza la funcin compara mediante el uso del realce y los
eigenfaces.
4.2. DISEO
4.2.1.
DIAGRAMA DE FLUJO
A continuacin se muestra el diagrama de flujo general del programa de

reconocimiento facial y el diagrama de la funcin compara, una de las ms
importantes y complejas ya que realiza todo el proceso de reconocimiento.
Csar Reyes Lpez
Pgina 48

Ilustracin 12: Diagrama de flujo del programa principal
Csar Reyes Lpez
Pgina 49

Ilustracin 13: Diagrama de flujo de la funcin COMPARA
Csar Reyes Lpez
Pgina 50

4.2.2.
ESTRUCTURA INTERNA
Como se ha visto en los diferentes diagramas de flujo, el programa se

divide en numerosos bloques, cada uno de los cuales consta de una o varias
funciones. En este apartado se va a proceder a una descripcin interna de
cada uno de estos bloques y funciones que constituyen el programa. No se
mostrar el cdigo constituyente de cada funcin ya que este aparece en el
apartado 7.3 CDIGO FUENTE, se pretende simplemente dar una visin
detallada de cmo se ha estructurado el programa de reconocimiento facial.
Para ello se ha seguido el orden de la pantalla de inicio del programa, como
puede verse en el bloque MAIN del diagrama de flujo del apartado anterior.
4.2.2.1.
MAIN Funcin principal
La funcin MAIN es el programa de reconocimiento en s, es el programa

principal, realiza todas las tareas y llamadas a otras funciones necesarias para
el correcto funcionamiento del sistema, interacta con los diferentes procesos
de los que consta, inicializando parmetros al inicio y liberndolos al terminar la
ejecucin del programa.
Esta funcin principal est formada por un bucle infinito del que se sale
cuando se elija la opcin de salir entre las opciones iniciales.
Solo toma como parmetro de entrada en su llamada inicial el tipo de
detector facial que se va a utilizar, fichero de entrenamiento.
Inicialmente la funcin MAIN define e inicializa algunas variables
necesarias para el correcto funcionamiento del programa como son las
variables de tiempo, utilizadas para indicar lo que ha tardado en realizarse el
proceso de reconocimiento y la variable para almacenar la opcin elegida por el
usuario en la pantalla principal del programa.
Por tanto esta funcin principal es la que se encarga de mostrar por
pantalla el men principal con sus diferentes opciones y dilogos de error.
Csar Reyes Lpez
Pgina 51

Antes de mostrar nada por pantalla el programa ha de saber cuantos

usuarios tiene el sistema, es decir, cuantas caras de usuarios tiene
almacenadas en su base de datos, para ello hace uso del fichero de texto
caras.txt, donde en su primera lnea se encuentra dicho nmero, con la
particularidad de que dicho nmero se muestra en el fichero como dos
caracteres, es decir, en el fichero, el nmero de usuarios se representa con dos
caracteres numricos, hasta 99 usuarios, que han de convertirse a un valor
entero para poder utilizarlo como tal.
Ilustracin 14: Imgenes de la base de datos
Para representar el men principal se han utilizado instrucciones del

lenguaje C que imprimen lneas por pantalla, ya que como puede leerse en los
objetivos del programa, la interfaz grfica ser sencilla y funcional. El resultado
es el siguiente:
Csar Reyes Lpez
Pgina 52

Ilustracin 15: Interfaz Grfica. Pantalla inicial
Una vez mostrada esta pantalla, el usuario ha de elegir una de las tres
opciones, 0 para introducir el rostro del usuario a la base de datos, 1 para el
reconocimiento de la cara del usuario mediante la comparacin con las ya
almacenadas en la base de datos y 2 para salir del programa. El programa
principal almacena el valor introducido y segn sea este, se actuar de una
manera u otra. Primero se comprueba que sea un carcter vlido, es decir, si
no es ni 0, 1 2, se imprime un mensaje de error y se vuelve a la pantalla
inicial. Si el valor introducido es alguno de los anteriores, dentro del bucle
infinito de la funcin MAIN se decide que lnea de accin seguir (ver diagrama
de flujo, Ilustracin 8). Para cada una de las dos primeras opciones, una vez
finalizada la ejecucin de sus bloques y funciones, han de liberarse las
variables iniciales, as como cerrar las ventanas abiertas hasta el momento,
para ello se utilizan las funciones cvDestroyAllWindows(), que cierra todas las
ventanas con imgenes abiertas, remove(*.jpg), que elimina los ficheros *.jpg
utilizados, imgenes auxiliares para el intercambio de informacin entre
funciones, y cvReleaseImage y cvReleaseCapture que liberan la memoria
de los diferentes tipos de variables.
Csar Reyes Lpez
Pgina 53

4.2.2.2.
NUEVO USUARIO
Si la opcin introducida es la de Nuevo Usuario ( 0 ), el proceso es el

siguiente:
Primero, se realiza la captura de una fotografa del usuario, para ello se
utiliza la funcin camara_y_foto, primer bloque del diagrama de flujo, la
imagen se obtiene de la cmara web mediante la pulsacin de una tecla. Una
vez que se dispone de una imagen del usuario, se le pide que introduzca su
nombre para poder asociar su cara a dicho nombre, funcin gets, la imagen
capturada se almacena en una variable para su procesado mediante la funcin
cvLoadImage
se
muestra
por
pantalla
mediante
las
funciones
cvNamedWindow, que crea una ventana y cvShowImage que la representa.

Estos ltimos pasos representan el siguiente bloque del diagrama de flujo, el
siguiente paso es la deteccin de una cara en la imagen capturada del usuario,
para ello, primero hay que cargar el tipo de detector que se va a utilizar, este
detector facial ha sido pasado como parmetro a la funcin principal en la
llamada de inicio del sistema. Para la deteccin de una cara en una imagen se
utiliza la funcin detect_and_draw que deja almacenada en memoria la cara
detectada y con un tamao determinado, o indica si no se ha encontrado una
cara.
Por tanto para poder continuar hay que tomar una decisin en funcin de
que se haya encontrado una cara en la imagen del usuario o no. Si se encontr
una cara se almacena el nombre introducido anteriormente por el usuario en el
fichero caras.txt incrementndose en uno el nmero de usuario o caras
almacenadas en la base de datos, la funcin que realiza esto es la funcin
almacena, posteriormente la foto con la cara del nuevo usuario se almacena
en la carpeta caras mediante la funcin guarda_foto, la foto es almacenada
con el nombre caraXX.jpg, donde XX es el nmero de usuarios actuales del
sistema. Si no se encontr una cara, se muestra por pantalla un mensaje de
error y se vuelve a la pantalla de inicio.
Csar Reyes Lpez
Pgina 54

4.2.2.3.
RECONOCIMIENTO
Si la opcin introducida es la de Reconocimiento ( 1 ), el proceso es el

siguiente:
En primer lugar se inicializan las variables utilizadas para calcular el
tiempo que se tarda en reconocer una cara desde el momento en el que es
detectada. El primer paso como se aprecia en el diagrama de flujo es al igual
que en el proceso de Nuevo Usuario es la captura de una fotografa del usuario
actual mediante la funcin camara_y_foto, el siguiente bloque es la deteccin
de la cara mediante la funcin detect_and_draw, igualmente, en funcin de
que se haya detectado una cara o no se actuar de diferente manera, si no se
ha detectado ninguna cara en la imagen del usuario, se muestra por pantalla un
mensaje de error y se vuelve al men principal.
Si se detecto una cara se procede a su comparacin con las ya
almacenadas en la base de datos de caras, para ello se utiliza la funcin
compara que devuelve como resultado un entero, el nmero de la cara de la
base de datos a la que se parece, si se cumplen los criterios establecidos,
mostrndola por pantalla mediante la funcin parecido, 0 en el caso que no
exista correspondencia con ninguna de las caras almacenadas.
Una vez que el proceso de comparacin de la cara ha finalizado, se
determina la duracin del proceso haciendo uso de la variables inicializadas al
comienzo del conjunto de bloques de reconocimiento y se muestra por pantalla
el resultado en segundos, posteriormente se utiliza la funcin guardian a la
que se le pasa como parmetro el valor devuelto por la funcin compara que
en funcin de dicho parmetro muestra por pantalla si el usuario tiene acceso
permitido o denegado al sistema.
4.2.2.4.
SALIR
Si la opcin introducida es la de Salir ( 2 ), simplemente se cierra la

ventana con el men principal, terminndose por tanto la ejecucin del
programa.
Csar Reyes Lpez
Pgina 55

FUNCIONES INTERNAS
4.2.3.
4.2.3.1.
Funciones de librera de C++
Funciones estndar en el uso de C y C++, como printf y fprintf para

imprimir caracteres por pantalla o en fichero, fopen, fclose, rewind y fseek para
el manejo de ficheros, time y clock para el manejo del tiempo y reloj del
sistema, etc
4.2.3.2.
Funciones de Librera de OpenCV
4.2.3.2.1.
cvLoadImage
Funcin de librera de OpenCV
Tipo:
IplImage* cvLoadImage( const char* filename, int
iscolor=1 )
Descripcin: funcin que carga una imagen desde un archivo

(filename) y devuelve un puntero a la imagen cargada, soporta
diferentes formatos, JPG, BMP, PNG, TIF, etc. Segn iscolor la
imagen ser cargada con diferentes modos de color, si iscolor >
0, la imagen es cargada con tres canales de color, si iscolor = 0,
se carga como escala de grises, y si es < 0, se carga como es
originalmente.
4.2.3.2.2.
cvSaveImage
Tipo:
int cvSaveImage( const char* filename, const CvArr*
image )
Descripcin: funcin que guarda una imagen (image) en un

determinado archivo (filename).
Csar Reyes Lpez
Pgina 56

4.2.3.2.3.
cvNamedWindow
Tipo:
Descripcin: funcin que crea una ventana con un determinado
int cvNamedWindow ( const char* name, int flags)
nombre (name) en la que pueden alojarse imgenes.
4.2.3.2.4.
cvShowImage
Tipo:
void cvShowImage ( const char* name, const CvArr*
image)
Descripcin: funcin que muestra una determinada imagen

(image) en una ventana especfica (name).
4.2.3.2.5.
load_object_detector
Tipo:
Descripcin: funcin que carga en memoria el tipo de detector de
load_object_detector ()
objetos a utilizar, en este caso un detector frontal facial.
4.2.3.2.6.
detect_and_draw_object
Tipo
void detect_and_draw_objects (IplImage* image,
CvHaarClassifierCascade* cascade, int do_pyramids)
Descripcin: funcin que recibe la imagen en la que ha de

buscarse una cara segn el clasificador cascade pasado como
parmetro. Utiliza a su vez la funcin cvHaarDetectObjects para
Csar Reyes Lpez
Pgina 57

detectar las caras, por cada cara detectada, dibuja un rectngulo

alrededor de la misma sobre la original, y se almacena su
contenido en una nueva imagen mediante la funcin creada para
tal efecto extract_and_norm. Si no se detecta ninguna cara se
notifica como un error.
4.2.3.2.7.
cvDestroyAllWindows
Tipo:
Descripcin: funcin que cierra todas las ventanas abiertas
void cvDestroyAllWindows ( void )
anteriormente.
4.2.3.2.8.
cvCalcEigenObjects
Tipo:
void*
void cvCalcEigenObjects( int nObjects, void* input,

output,
int
ioFlags,
int
ioBufSize,void*
CvTermCriteria* calcLimit,IplImage* avg,float*
userData,
eigVals )
Descripcin: funcin que crea unas bases ortonormales y el

objeto promedio de un grupo de objetos de entrada, con una serie
de condiciones y restricciones. Esta funcin utiliza la matriz de
covarianza, calculada para el grupo de objetos de entrada.
4.2.3.2.9.
cvEigenProjection
Tipo:
int
void
nEigObjs, int
cvEigenProjection(
ioFlags, void*
void*
userData,
eigInput,
float*
coeffs, IplImage* avg,IplImage* proj )
Csar Reyes Lpez
Pgina 58

Descripcin: funcin que calcula la proyeccin de un objeto dentro

del sub-espacio eigen, es decir, restablece un objeto usando las
bases de eigenobjects calculadas con anterioridad, el objeto
promedio, y la descomposicin en coeficientes del objeto
restaurado.
4.2.3.2.10.
cvEigenDecomposite
Tipo:
int
void
cvEigenDecomposite(
nEigObjs, void*
eigInput, int
userData, IplImage* avg, float*
IplImage*
ioFlags,
obj,
void*
coeffs )
Descripcin: funcin que calcula toda la descomposicin en

coeficientes para el objeto de entrada usando las bases de
eigenobjects calculadas anteriormente y el objeto promedio.
4.2.3.2.11.
cvReleaseImage
Tipo:
Descripcin: funcin que libera memoria de la estructura image,
void cvRelesaseImage ( IplImage** image )
datos y manejador.
4.2.3.2.12.
cvReleaseCapture
Tipo:
Descripcin: funcin que libera memoria de la estructura capture.
Csar Reyes Lpez
void cvRelesaseCapture (CvCapture** capture)
Pgina 59

4.2.3.2.13.
cvCreateMemStorage
Tipo:
CvMemStorage*
cvCreateMemStorage
(int
block_size = 0)
Descripcin: funcin que crea un bloque de memoria para

almacenar y devuelve un puntero al mismo.
4.2.3.2.14.
cvReleaseMemStorage
Tipo:
void
cvRelesaseMemStorage
(CvMemStorage**
storage)
Descripcin: funcin que libera los bloques de memoria asignados

con anterioridad.
4.2.3.2.15.
cvPyrDown
Tipo:
void cvPyrDown ( cont CvArr* src, CvArr* dst, int
filter = CV_GAUSSIAN_5x5 )
Descripcin: funcin que realiza un submuestreo a una imagen

mediante descomposicin piramidal de Gauss. Primero realiza la
convolucin de la imagen con el filtro y luego submuestrea la
imagen rechazando incluso filas y columnas.
4.2.3.2.16.
cvHaarDetectObjects
Tipo:
CvSeq* cvHaarDetectObjects( const CvArr* image,
CvHaarClassifierCascade* cascade, CvMemStorage* storage,
Csar Reyes Lpez
Pgina 60

double scale_factor=1.1, int min_neighbors=3, int flags=0, CvSize

min_size=cvSize(0,0))
Descripcin: funcin que encuentra regiones rectangulares en

una imagen parecidas a una serie de muestras almacenadas en
una estructura del tipo cascade, clasificador. La funcin escanea
la imagen varias veces con diferentes tamaos de rectngulos,
devuelve punteros a las zonas de la imagen donde se han
encontrado objetos parecidos a los de referencia.
4.2.3.2.17.
cvGetSeqElem
Tipo:
Descripcin: funcin que encuentra los elementos de una
char* cvGetSeqElem (const CvSeq*, int index)
secuencia indexada por index, devuelve 0 si no los encontr.
4.2.3.2.18.
cvRectangle
Tipo:
void cvRectangle ( CvArr* img, CvPoint pt1, CvPoint
pt2, CvScalar color, int thickness = 1, int line_type = 8, int shift =

0)
Descripcin: funcin que dibuja un rectngulo, dados dos vrtices

opuestos, con una lnea de un color y grosor determinado.
4.2.3.2.19.
cvResize
Tipo:
void cvResize ( const CvArr* src, CvArr* dst, int
interpolation = CV_INTER_LINEAR )
Csar Reyes Lpez
Pgina 61

Descripcin: funcin que cambia el tamao de una imagen origen

mediante interpolacin al tamao de la imagen destino.
4.2.3.2.20.
cvCaptureFromCAM
Tipo:
Descripcin: funcin que inicializa la captura de video de una
cvCapture* cvCaptureFromCAM ( int index )
cmara, indicada por index, se utiliza -1 si el sistema solo dispone

de una cmara.
4.2.3.2.21.
cvGrabFrame
Tipo:
Descripcin: funcin que captura un fotograma desde una cmara
int cvGrabFrame ( CvCapture* capture )
y lo almacena internamente.
4.2.3.2.22.
cvRetrieveFrame
Tipo:
Descripcin: funcin que devuelve un puntero a la imagen
IplImage* cvRetrieveFrame ( CvCapture* capture )
almacenada internamente por cvGrabFrame.
4.2.3.2.23.
cvCopy
Csar Reyes Lpez
Pgina 62

Tipo:
void cvCopy ( const CvArr* src, CvArr* dst, const
CvArr* mask = NULL )
Descripcin: funcin que copia una tabla o imagen en otra.
4.2.3.2.24.
cvFlip
Tipo:
void cvFlip ( const CvArr* src, CvArr* dst = NULL, int
flip_mode = 0 )
Descripcin: funcin que rota una tabla 2D o una imagen sobre

los ejes horizontal, vertical o ambos.
4.2.3.2.25.
cvCvtColor
Tipo:
void cvCvtColor ( const CvArr* src, CvArr* dst, int
code )
Descripcin: funcin que convierte el espacio de color de una

imagen a otro.
4.2.3.2.26.
cvWaitkey
Tipo:
Descripcin: funcin que espera la pulsacin de una tecla
int cvWaitKey ( int delay = 0 )
indefinidamente, si delay = 0 o un tiempo determinado por delay

en milisegundos. Devuelve el cdigo de la tecla presionada o 1 si
no se pulso ninguna en el tiempo indicado.
Csar Reyes Lpez
Pgina 63

4.2.3.3.
4.2.3.3.1.
Funciones Propias
camara_y_foto
Funcin propia
Tipo
Descripcin: funcin que accede a la cmara Web del equipo y
IplImage* camara_y_foto (CvCapture* capture)
realiza la captura de una fotografa cuando el usuario pulse una

tecla. Muestra por pantalla la ventana con la visin de la cmara y
la fotografa cuando esta es capturada.
4.2.3.3.2.
almacena
Funcin propia
Tipo
Descripcin: funcin que almacena el nombre del nuevo usuario
int almacena ( void )
en el fichero caras.txt, actualizando el nmero de usuarios. Para

ello, posiciona el puntero al principio del fichero, obtiene el
nmero de usuarios actuales leyendo los dos primeros caracteres
del fichero, los convierte a entero restando 48 a su valor ASCII,
aumenta en 1 el nmero de usuarios, y vuelve a escribir el nuevo
nmero de usuarios al comienzo del fichero. Posicionando el
puntero del fichero al final del mismo, escribe el nombre del nuevo
usuario. Cierra el fichero y devuelve en un entero el nmero de
usuarios actuales.
4.2.3.3.3.
guarda_foto
Funcin propia
Tipo
Csar Reyes Lpez
void guarda_foto ( int, IplImage* )
Pgina 64

Descripcin: funcin que guarda la foto de la cara del nuevo

usuario dentro de la carpeta caras del directorio de trabajo y
escribe su nombre al final del fichero caras.txt.
4.2.3.3.4.
compara
Funcin propia
Tipo
Descripcin: funcin que compara la nueva imagen del usuario
int compara ( IplImage* )
con las almacenadas anteriormente. Esta funcin genera dos

ficheros de texto, values.txt y values_norm.txt donde se van
almacenando los diferentes valores de los procesos que se
siguen durante la ejecucin del programa con el fin de un estudio
posterior off-line. En primer lugar, almacena las imgenes de la
base de datos y la original convertidas a escala de grises en una
tabla, y las mismas imgenes pero realzadas, es decir,
aplicndoles la funcin relce_mono en otra. Estas tablas o
vectores
de
imgenes
son
utilizadas
por
la
funcin
cvCalcEigenObjects para la obtencin de los eigenobjects y

eigenvalues, la descomposicin en componentes principales es
llevada a cabo por la funcin cvEigenDecomposite, los valores
resultantes son normalizados para un mejor tratamiento a la hora
de calcular la distancia entre vectores de una y otra cara. Una vez
que se tiene la distancia entre vectores, es decir, la distancia,
entre la cara del usuario actual al resto de caras almacenadas en
la base de datos, se procede a evaluar dicha distancia junto con
un conjunto de condiciones para determinar si se reconoce o no al
usuario. Si se cumplen las condiciones, la cara es por tanto
reconocida, se llama a la funcin parecido y devuelve el nmero
de la cara de la base de datos a la que se parece la original, si no,
devuelve 0.
Csar Reyes Lpez
Pgina 65

4.2.3.3.5.
realce_mono
Funcin propia
Tipo
Descripcin: funcin
void realce_mono (void )

que
realza
una
imagen
mediante
el
procedimiento de igualacin de histograma. Utiliza las imgenes

de las caras en niveles de gris. Se construye una funcin que es
la suma para cada punto de las probabilidades de los niveles de
gris de la imagen a tratar, esta funcin es no multievaluada y
montona creciente, realizando la transformada inversa y
aplicndosela a la imagen original se tendr la imagen realzada,
el nuevo histograma se ver expandido con respecto al original.
4.2.3.3.6.
parecido
Funcin propia
Tipo
Descripcin: funcin que muestra por pantalla la cara a la que el
void parecido ( int )
usuario actual se parece. Es llamada por la funcin compara si se

han cumplido las condiciones de reconocimiento.
4.2.3.3.7.
extract_and_norm
Funcin propia
Tipo
void extract_and_norm ( IplImage* image, CvRect
FACE_rect, int scale )
Descripcin: funcin que extrae la cara de una imagen en la que

ya se ha detectado, almacenndola con un tamao estndar de
trabajo de 128 x 128 pxeles. Trabaja con la imagen de la cara
como si se tratara de una matriz multidimensional, es decir, para
cada
Csar Reyes Lpez
valor
de
fila
columna,
existen
tres
niveles,
Pgina 66

correspondientes a los valores RGB de la imagen, rojo, verde y

azul. Para redimensionar el tamao de la cara original a 128 x 128
pxeles se utiliza la funcin cvResize.
4.2.3.3.8.
guardian
Funcin propia
Tipo
Descripcin: funcin que segn el resultado devuelto por la
void guardian ( int )
funcin compara, 0 si no se ha encontrado correspondencia

entre caras, o el nmero de la cara a la que se parece el usuario
actual, deniega o permite el acceso al sistema, como forma de
validar la permanencia o no al grupo cerrado de usuarios,
mostrando un mensaje por pantalla, ACCESO DENEGADO, en
caso negativo, o ACCESO PERMITIDO y NOMBRE DEL
USUARIO: << nombre del usuario >> en caso afirmativo.
4.3. FUNCIONAMIENTO
El funcionamiento del sistema de reconocimiento facial diseado es
bastante intuitivo, sobre todo en lo referente a la interfaz grfica. El ejecutable
del programa es llamado por un fichero .cmd, secuencia de comandos de
Windows, en el que se llama al ejecutable del programa creado por el
compilador de C++ y se le pasa el parmetro que necesita dicho programa
principal como ya se ha comentado con anterioridad, el fichero de
entrenamiento para el detector facial, fichero tipo .xml.
Csar Reyes Lpez
Pgina 67

Una vez ejecutado el programa, la pantalla inicial es la siguiente:
Ilustracin 16: Pantalla inicial
Puede
observarse
como
debajo
del
nombre
del
programa
RECONOCIMIENTO FACIAL, aparece el nmero de usuarios actual, en este

caso 20. Este nmero indica el nmero de caras que el sistema tiene
almacenadas, pudiendo estas pertenecer varias a una misma persona.
A continuacin se muestran las diferentes opciones que se tienen,
teniendo el usuario actual que teclear el nmero de la elegida para
seleccionarla. 0, Nuevo Usuario, si se quiere almacenar una nueva cara dentro
de la base de datos del sistema, 1, Reconocimiento, si se desee que el sistema
reconozca la cara del usuario actual y muestre si tiene acceso permitido o
denegado, y 2, Salir, para terminar con el uso del programa.
Si el nmero o carcter introducido no es ninguno de los anteriores
(0,1,2) el sistema muestra un mensaje de error e indica que se vuelva a
intentar.
Csar Reyes Lpez
Pgina 68

Ilustracin 17: Nmero de opcin introducido incorrecto
NUEVO USUARIO
Si se elige la opcin Nuevo Usuario, es decir, se introduce el carcter
0 por teclado, el sistema muestra por pantalla el mensaje Pulse una tecla
para fotografiarse y abre una ventana llamada Capturando donde se
muestra la imagen proveniente de la cmara web instalada en el sistema.
Ilustracin 18: Opcin 0, Nuevo Usuario
Cuando se pulsa una tecla, la imagen de la pantalla de la cmara web se

congela y el sistema pide al usuario que introduzca un nombre con el que su
cara, si se detecta en la imagen, ser almacenada. Una vez introducido el
Csar Reyes Lpez
Pgina 69

nombre, el sistema procesa la imagen capturada e intenta detectar la cara del

usuario y si ha sido posible, muestra en una ventana denominada Cara de
usuario la cara detectada.
Ilustracin 19: Introduccin del nombre del nuevo usuario Cesar Demo
Ilustracin 20: Cara de usuario Cesar Demo detectada
Una vez que la cara ha sido detectada, el proceso de Nuevo Usuario

ha finalizado, el sistema espera un tiempo (15 seg.), y si no se pulsa ninguna
tecla, vuelve a la pantalla inicial.
Csar Reyes Lpez
Pgina 70

El nombre de usuario ha sido almacenado en el fichero caras.txt y el

nmero de usuarios se ha aumentado en uno, en este caso ahora habr 21,
como puede observarse en el fichero caras.txt mostrado a continuacin.
Ilustracin 21: Fichero caras.txt con el nuevo usuario almacenado
La captura de la fotografa de entrada del usuario es muy importante: si

una vez mostrada la pantalla Capturando que visualiza la imagen de la
cmara Web se pulsa una tecla, ha de tenerse en cuenta que la imagen a
capturar ha de cumplir ciertos requisitos de iluminacin y posicin, como se ha
comentado en apartados anteriores para que el trabajo del detector de caras
sea satisfactorio.
A continuacin se muestra un ejemplo de una mala posicin del sujeto
en el momento de la captura de su fotografa.
Csar Reyes Lpez
Pgina 71

Ilustracin 22: Captura de una fotografa de usuario con mala posicin
El sistema antes de analizar la fotografa pide al usuario que introduzca

su nombre, una vez introducido y la fotografa tomada analizada por el detector
facial, se muestra el mensaje de error, ya que no se ha podido encontrar una
cara en la imagen debido a la mala posicin del usuario frente a la cmara web.
Ilustracin 23: Error, No se ha encontrado una cara
RECONOCIMIENTO
Csar Reyes Lpez
Pgina 72

Si se elije la opcin de Reconocimiento, es decir, se introduce el

carcter 1 por teclado, la pantalla que muestra el sistema es la misma que la
del caso Nuevo Usuario, ya que lo primero que se ha de hacer es capturar
una imagen en la que detectar la cara del usuario actual. Por tanto, aparece la
ventana Capturando con la imagen proveniente de la cmara Web.
Ilustracin 24: Opcin 1, Reconocimiento
Una vez capturada una fotografa del usuario el sistema comprueba que
exista una cara en la imagen para poder aplicar el proceso de reconocimiento,
si no se encuentra ninguna cara, mostrar un mensaje de error como en el
mismo caso de Nuevo Usuario. Si el proceso de deteccin encuentra una
cara, pasa el control al mdulo compara, que realizar el proceso de
reconocimiento de dicha cara con las que ya tiene almacenadas. El resultado
de dicho proceso puede ser, usuario reconocido, o no.
Si la cara del usuario actual es reconocida, es decir, se han cumplido
los criterios establecidos, el sistema muestra diferentes mensajes. Primero
muestra la exactitud con la que la cara ha sido reconocida, es decir, la
probabilidad de que el usuario actual pertenezca a los usuarios ya
almacenados; despus, el tiempo que se ha tardado en el proceso de
reconocimiento, desde que se captur la foto del usuario actual y su
reconocimiento. Posteriormente el sistema muestra el mensaje de ACCESO
PERMITIDO !!! y el nombre del usuario al que su cara se parece.
Csar Reyes Lpez
Pgina 73

Ilustracin 25: Usuario Reconocido. Acceso Permitido
En este caso, la probabilidad de exactitud ha sido del 77%, el tiempo de

cmputo de 1.20 segundos y el nombre del usuario al que se parece el actual
es el ltimo introducido en la base de datos, el introducido en el ejemplo
anterior de nuevo Usuario, Cesar Demo.
El programa tambin muestra dos ventanas, una con la imagen de la
cara del usuario actual y otra con la cara a la que se parece, para que puedan
ser comparadas visualmente.
Ilustracin 26: Caras de usuario actual y parecido (Reconocimiento correcto)
Csar Reyes Lpez
Pgina 74

Si la cara del usuario actual, no es reconocida, el sistema muestra un

mensaje en el que se indica que no se encuentra una correspondencia entre el
usuario actual y las caras almacenadas, esto es debido a que no se han
cumplido los criterios establecidos para el reconocimiento. Posteriormente,
indica el tiempo de cmputo al igual que en el caso positivo, y un mensaje de
ACCESO DENEGADO !!!
Ilustracin 27: Usuario No Reconocido. Acceso Denegado
Al igual que en el caso anterior, Nuevo Usuario, transcurrido un tiempo

(15 seg.) tras la finalizacin del proceso de reconocimiento, si no se pulsa
ninguna tecla, el sistema vuelve a la pantalla inicial.
SALIR
Si se elije la opcin Salir, es decir, se introduce el carcter 2 por
teclado, en el men principal, simplemente se cierra la ventana actual y por
tanto se finaliza el programa.
Csar Reyes Lpez
Pgina 75

4.4. CRITERIOS PARA EL RECONOCIMIENTO

En este apartado se van a describir los criterios que utiliza la funcin
compara para llevar a cabo el reconocimiento facial de un usuario. Para ello
se va a hacer uso de dos ficheros de texto auxiliares en los que se almacenan
los datos de los diferentes procesos que se siguen en la aplicacin del mtodo
de los Eigenfaces. Los ficheros de texto values.txt y values_norm.txt,
tienen la misma estructura, la diferencia radica en que los datos que se
almacenan en values.txt provienen de la imgenes de las caras almacenadas
en la base de datos ms la actual, y los datos de values_norm.txt, provienen
de las mismas caras pero una vez realzadas mediante la funcin
realce_mono, que les realiza una igualacin de histograma.
Una vez que las imgenes de las caras tanto normales como realzadas
han sido descompuestas en sus componentes principales, se han calculado
sus eigenobjects y eigenvalues, y estos han sido normalizados, se puede
proceder a determinar la distancia entre unas caras y otras. De la forma en la
que ha sido diseado el algoritmo de reconocimiento, el primer valor del
conjunto de eigenvectors, corresponde a la cara del usuario que ha de ser
reconocido y el resto, al de las caras almacenadas, por tanto la distancia que
interesa es el valor mnimo de la distancia de la primera cara a las dems, es
decir, la distancia mnima entre el vector 0 y el resto de vectores, tantos como
caras se tengan almacenadas.
Para determinar si la distancia mnima entre el vector 0 (cara del usuario
actual) y el conjunto de vectores restantes puede interpretarse como vlida, en
el sentido de que se d por vlido el reconocimiento, ha de tenerse un umbral
de discernimiento, valor por encima del cual se considere que el
reconocimiento no es posible; la probabilidad de equivocarse sera muy alta.
Dicho umbral de reconocimiento se ha obtenido empricamente y toma
un valor que depende del nmero de caras almacenadas en el sistema, ya que
los valores de las componentes principales varan y dependen del nmero de
imgenes del sistema. El umbral de reconocimiento viene dado por la recta:
Csar Reyes Lpez
Pgina 76

umbral = (3 + 0.15 n _ fotos)

donde n_fotos es el nmero de caras almacenadas en el sistema ms una, la
del usuario actual.
Segn esto, la primera condicin que ha de cumplirse para que un
usuario sea reconocido con una cierta probabilidad de xito es que la mnima
distancia entre su cara (vector 0) y el resto de caras est por debajo del umbral
de reconocimiento.
En la siguiente figura puede observarse como el menor valor de la
distancia entre el vector 0 y el resto est por debajo del umbral slo se utiliza el
umbral para el caso de valores con las imgenes normales, no las realzadas.
Ilustracin 28: Valores de las distancias entre caras
Csar Reyes Lpez
Pgina 77

Para las distancias calculadas con las imgenes realzadas no se ha

tenido en cuenta el umbral, ya que habra que tener otro diferente, puesto que
al igualar los histogramas de las imgenes estas se modifican y sus
componentes principales tambin, sin embargo, estas distancias realzadas
introducen la siguiente condicin de reconocimiento, que no es ms que una
forma de hacer ms robusto el sistema. Esta condicin es la siguiente: puesto
que como la primera condicin indicada es que la distancia mnima del vector 0
al resto, para el caso normal, sea menor que el umbral, se tendr un nmero de
vector que sea el que tenga dicha distancia mnima con el vector 0, y por tanto
un nmero de cara ( se podra interpretar como la cara que ms se parece a la
del usuario actual), ha de cumplirse por tanto que dicho nmero de cara para el
caso normal, coincida con el nmero de cara para el caso realzado, es decir,
que la distancia mnima del vector 0 al resto de vectores para el caso realzado,
independientemente de que este valor sea mayor que el umbral del caso
normal, se de para el mismo nmero de vector (nmero de cara) que en el caso
normal.
En la ilustracin anterior puede verse cmo ambos nmeros de cara
coinciden, la distancia menor se produce para el vector o cara 21.
En el apartado de ANEXOS se muestran los ficheros de texto
values.txt y values_norm.txt completos, es decir, con todos los valores de
eigenobjects,
descomposicin
en
valores
principales,
coeficientes
normalizados, y vectores de distancia. Para estos ejemplos se ha omitido la

impresin de esos resultados al carecer de valor para lo que se pretende
explicar, por lo que solo se muestran las distancias entre vectores.
Puede observarse como, adems de la distancia del vector 0 al resto de
vectores, aparece la distancia de cada vector al grupo de vectores, es decir, se
muestra la distancia de cada cara al resto, donde se muestra que la menor
distancia de una cara es consigo misma, distancia 0, ya que son iguales, por lo
que, esos valores 0 no se tienen en cuenta a la hora de determinar cual es el
vector con el que se tiene la menor distancia, ya que siempre sera uno mismo.
Csar Reyes Lpez
Pgina 78

Gracias a este clculo y representacin de todas las distancias, se

puede imponer una ltima condicin para el reconocimiento.
Si se tiene el nmero de cara o vector N que posee la distancia menor a
la cara actual o vector 0, se comprueba que para dicho vector N, la menor
distancia se cumple tambin inversamente para el vector 0, es decir, que la
mnima distancia, una vez calculada para el caro 0 N, es mnima tambin en
el sentido inverso, N 0.
En el ejemplo de la ilustracin anterior se vio como la mnima distancia
se produca para el vector 21, por tanto, viendo las distancias del vector 21 ha
de cumplirse que el valor menor se encuentre con el vector 0, esto puede
corroborarse mirando los valores del fichero para el vector 21, mostrado a
continuacin.
La tercera condicin ser la siguiente: estos nmeros de caras inversos,
para el caso normal y realzado, deben coincidir, y ser igual a 0 para que el
usuario sea reconocido.
Esta condicin no es concluyente ni determinante por s sola, ya que si
se cumplen las dos anteriores, se cumplir, al ser los valores recprocos, y si no
se cumple, seguro no se habrn cumplido las anteriores, pero se utiliza para
dar una mayor robustez al reconocimiento en los casos positivos. Aunque
puede cumplirse sin haberlo hecho la segunda, el reconocimiento seguir
siendo negativo.
Para el ejemplo anterior, estos valores pueden observarse a
continuacin.
Csar Reyes Lpez
Pgina 79

Ilustracin 29: Valores inversos de las distancias entre caras
Resumiendo, se tienen tres condiciones que han de cumplirse para que

el reconocimiento de una cara sea vlido:
1. La distancia menor de la cara del usuario actual (vector 0 ) al
resto debe estar por debajo de un umbral de reconocimiento.
2. El nmero de la cara a la que la cara del usuario actual presenta
una distancia menor, tanto para el caso normal como para el caso
realzado, debe coincidir.
Csar Reyes Lpez
Pgina 80

3. El nmero de la cara con la distancia inversa menor a la cara del

usuario actual, tanto para el caso normal como para el caso
realzado, debe coincidir.
Por tanto, para el ejemplo que viene estudindose puede concluirse que,
puesto que se han cumplido las tres condiciones, este usuario sera
reconocido.
A continuacin se muestra un caso en el que el usuario no ser
reconocido ya que no se cumplen los criterios de reconocimiento, en particular,
el nmero de cara en el caso directo ( 0 N ) no coinciden an estando para el
caso normal, su valor por debajo del umbral.
Ilustracin 30: Ejemplo de reconocimiento fallido. No cumple 2 condicin
Csar Reyes Lpez
Pgina 81

Se observa como el valor menor (3.84) para el caso normal, se

encuentra por debajo del umbral (6.30), pero el nmero de esta cara, (vector 6)
no coincide con el valor de la cara con distancia mnima para el caso realzado
(vector 4). Por tanto, no se cumple la segunda condicin.
Sin embargo, la tercera condicin para este caso particular, se cumple,
como se muestra en la siguiente figura.
Ilustracin 31: Cumplimiento de la 3 condicin de reconocimiento
A continuacin, se muestra un caso en el que no se cumplen ni la

primera ni la segunda condicin de reconocimiento, que son las determinantes.
Csar Reyes Lpez
Pgina 82

El valor mnimo de los vectores normales, 6.49 para el vector 8, se

encuentra por encima del valor umbral 6.30 y los nmeros de cara no
coinciden, 8 para el caso normal y 11 para el caso realzado. Por tanto, para
este caso, el usuario no sera reconocido.
Ilustracin 32: Fallo en el cumplimiento de la 1 y 2 condicin de reconocimiento
Csar Reyes Lpez
Pgina 83

COMPARA. Realce y Eigenfaces
4.4.1.
A continuacin se muestran las imgenes que forman parte del proceso

de reconocimiento una vez dentro de la funcin compara.
Las imgenes almacenadas en la base de datos son las siguientes:
Ilustracin 33: Ejemplo. Imgenes de la base de datos
Como se ha descrito anteriormente, la funcin compara trabaja con las

imgenes originales convertidas a escala de grises y con sus correspondientes
imgenes realzadas, con las que posteriormente se construyen los eigenfaces.
En la siguiente ilustracin se muestran los dos tipos de imgenes con los
que se trabaja.
Csar Reyes Lpez
Pgina 84

Csar Reyes Lpez
Pgina 85

Ilustracin 34: Imgenes originales y realzadas en escala de grises
Con las imgenes anteriores se calculan los eigenfaces, es decir,

proyecciones de dichas imgenes en el espacio de sus componentes
principales, el resultado de dichas proyecciones es el siguiente:
Csar Reyes Lpez
Pgina 86

Csar Reyes Lpez
Pgina 87

Ilustracin 35: Eigenfaces
Para poder llevar a cabo el reconocimiento hace falta una cara inicial,
para este caso ha sido la siguiente:
Ilustracin 36: Imagen del usuario a reconocer. Original y realzada
Puede observarse en la figura que muestra los eigenfaces como existen

algunas imgenes que se parecen mucho a la original, por tanto, esas
imgenes tendrn vectores de distancia mnimos y sern candidatas para un
reconocimiento positivo.
Csar Reyes Lpez
Pgina 88

4.5. RESULTADOS
En este apartado se van a mostrar los resultados obtenidos en cuanto a
tiempo de cmputo y fiabilidad en los reconocimientos, dos de las
caractersticas restrictivas que se tenan en los objetivos iniciales del sistema.
En la siguiente tabla se muestra para diferentes nmeros de usuarios, el
tiempo de cmputo, tiempo medio que tarda el sistema en reconocer o no a un
usuario; el porcentaje de xito, indica en media la probabilidad con la que un

usuario ser reconocido positivamente, como fallos se encuentran, que no se
reconozca como perteneciente a la base de datos, o que se reconozca como
un usuario distinto al que es; y el porcentaje de reconocimiento, indica en
media con que probabilidad se parece la cara de un usuario reconocido a la
almacenada en la base de datos con anterioridad.
N de usuarios
Tiempo de cmputo
% xito
% Reconocimiento
0.98 seg.
98 %
81 %
10
1.25 seg.
97 %
79 %
20
1.72 seg.
92 %
77 %
80
6.18 seg.
88 %
72 %
Ilustracin 37: Tabla de resultados
Se observa como para un nmero de usuarios igual a 20, el tiempo de

cmputo en media no sobrepasa an los 2 segundos, caracterstica muy
deseable, sobre todo, tenindose en cuenta que la probabilidad de xito ronda
el 97 % y el porcentaje de parecido de la cara de usuario con la ya almacenada
se acerca al 80 %.
El porcentaje de reconocimiento sigue la siguiente ley:
porcentaje =
Csar Reyes Lpez
(umbral 100 49 menor )

umbral
Pgina 89

donde umbral, es el umbral de reconocimiento, y menor, es la distancia menor

de la cara del usuario actual al resto, de ah que si el valor menor coincide con
el umbral, caso crtico, la probabilidad de reconocimiento sea del 51 %.
La disminucin de la probabilidad de xito debido a que un usuario o
bien no sea reconocido o bien sea reconocido pero como otro usuario se
reparte de una manera desigual. Si se tiene un 98 % de xito, el 2 % de fracaso
es debido en media a un 1.7 % por incumplimiento de los criterios de
reconocimiento, es decir, el usuario no es reconocido, y a un 0.3 % de
equivocacin, el usuario es reconocido como otro.
Este 0.3 % para el caso de 5 usuarios puede llegar al 2 % para el caso
de 80 usuarios, valor que sin ser demasiado alto, no deja de ser una
caracterstica a tener en cuenta a la hora de aplicar el sistema a un conjunto
muy numeroso de usuarios. Al estar este sistema de reconocimiento facial
enfocado como parte de un conjunto domtico, el nmero de usuarios ser
reducido
valores
inferiores
al
pueden
ser
admisibles.
Estos valores pueden ser reducidos disminuyendo el valor del umbral de

discernimiento, imponiendo valores ms restrictivos.
Csar Reyes Lpez
Pgina 90

5. CONCLUSIONES Y LNEAS DE
DESARROLLO FUTURAS
5.1. ESTRUCTURA
En este apartado se muestran las conclusiones a las que se ha llegado
una vez finalizado el proyecto fin de carrera, primera seccin, y un anlisis de
las lneas de avance en el campo del reconocimiento facial y futuros trabajos y
mejoras tomando como punto de partida este proyecto, segunda y ltima
seccin.
5.2. CONCLUSIONES
Recordando los objetivos iniciales del proyecto: << Por formar parte de
una instalacin domtica la solucin aportada deba de cumplir ciertos
requisitos: uno de ellos era la utilizacin de una cmara web como sistema de
Csar Reyes Lpez
Pgina 91

captacin de imgenes, dado su bajo coste y su alta implantacin en el

mercado de consumo de los ordenadores personales. Otro requisito, quizs el
ms restrictivo respecto al software, era que el tiempo de procesado desde la
captura de la cara del usuario hasta la indicacin de su acceso o prohibicin de
entrada fuese de un par de segundos como mximo. >>. Puede concluirse que
los objetivos han sido cumplidos satisfactoriamente, se ha desarrollado un

sistema de reconocimiento facial robusto, rpido y con un coste de
implantacin dentro de un sistema domtico sustancialmente econmico.
En el apartado de Resultados, puede apreciarse como los tiempos de
cmputo para un nmero de usuarios en torno a 20 no supera los 2 segundos
en media, tiempo ms que suficiente para un sistema de reconocimiento facial
de estas caractersticas.
Aunque el desarrollo ha sido enfocado de una manera experimental, la
realizacin prctica del mismo no dista del trabajo realizado. Habra que contar
con un mecanismo que permitiera abrir la puerta una vez el usuario fuese
reconocido y cambiar la interfaz grfica para que funcionase de manera
autnoma e ininterrumpidamente.
Sin embargo el sistema es susceptible a mejoras, que se detallarn en el

siguiente apartado de lneas futuras de avance, como son, la fuerte
dependencia a las condiciones de iluminacin, supuestas constantes para el
desarrollo del programa, y a la orientacin y posicin de la cara del sujeto, tanto
en el proceso de deteccin como de reconocimiento.
5.3. LNEAS DE DESARROLLO FUTURAS

La palabra domtica, deriva de la unin de domus (casa) e informtica. En
la actualidad, el auge de las tecnologas de la informacin, telecomunicaciones
y la amplia evolucin e integracin de sistemas electrnicos e informticos est
haciendo que el campo de la domtica obtenga un crecimiento exponencial.
Csar Reyes Lpez
Pgina 92

En lo referente al campo que cubre este proyecto, cada da hay

disponibles en el mercado cmaras con lentes y sensores mucho ms precisos
y potentes y equipos informticos mucho ms rpidos y pequeos, que hacen
posible una ms fcil, cmoda, robusta y rpida implantacin de estos
sistemas.
Como se ha indicado en el apartado anterior existen mejoras aplicables al
sistema de reconocimiento facial diseado como son la independencia a las
condiciones de iluminacin y a la posicin y orientacin del sujeto frente a la
cmara.
Condiciones de iluminacin
El problema de las condiciones de iluminacin viene determinado por la

iluminacin arbitraria que puede tener un lugar de trabajo o el lugar donde se
implante la cmara del sistema de reconocimiento facial. Como se ha
comentado con anterioridad, dichas variaciones de iluminacin pueden
invalidar por completo el reconocimiento de la cara de un usuario incluso
imposibilitar la deteccin de la cara del mismo dentro de una imagen.
Por tanto una lnea de desarrollo futuro podra ser la supresin en el
entorno del sistema de reconocimiento facial de las variaciones de iluminacin.
Podra disponerse de varios sistemas de iluminacin o una mezcla de ambos,
un sistema de iluminacin directa sobre el usuario lo suficientemente potente y
robusto para que independientemente de la hora y condiciones climatolgicas
del da la captacin de la imagen de la cara del usuario pareciese constante,
sistema de iluminacin que se activase mediante un sensor de presencia o a la
vez que se activara el sistema de deteccin, o un sistema de iluminacin
indirecta que hiciera constante las condiciones de iluminacin en el entorno de
captacin de la imagen del usuario.
Se tiende, a que los procesos que tienen que interactuar con los
usuarios sean lo menos agresivos posible, por lo que el sistema de iluminacin
Csar Reyes Lpez
Pgina 93

debera ser capaz de adaptarse mediante sensores de presencia, clima e

iluminacin y homogeneizar el entorno de tal forma que esto fuera inapreciable
por el usuario.
Posicin y orientacin del sujeto
Puesto que el sistema ha de interactuar con una persona, existen

parmetros que el sistema no puede controlar a priori aunque s corregir e
intentar solucionar; uno de ellos es la posicin y orientacin que el sujeto
presenta frente a la cmara que captura la imagen de su cara.
Es fcil entender que el tamao de la cara de un nio no es el mismo
que el de un adulto y ni siquiera entre adultos, ya que para un punto del suelo
dado, el plano de la cara de una persona de 1,80 metros se encontrar mas
cerca del plano de una cmara situada en el techo que del de una persona de
1,60 metros y por tanto habra que estandarizar dichos tamaos. Esto se
consigue corregir en el programa diseado mediante el cambio de tamao de
una cara detectada a un tamao estndar de 128 x 128 pxeles y as tratarlas a
todas por igual.
Sin embargo existen otros problemas derivados de este. El sistema
desarrollado utiliza un detector facial frontal, es decir, cualquier cara de usuario
que no est paralela al plano de captacin, ser descartada. Este problema
podra solucionarse si se tuvieran ms tipos de detectores faciales y se pudiera
encontrar una cara en una imagen fuera cual fuese su orientacin. De hecho
existen tcnicas para corregir ligeras rotaciones y cambios de posicin en las
caras, pero consumen mucha potencia computacional y hacer uso de varios
detectores en paralelo encarecera tambin computacionalmente el sistema.
Por tanto una segunda lnea de desarrollo sera la obtencin de un
mtodo que fuera capaz de obtener la cara del usuario para mltiples
posiciones y orientaciones, pudindose estas almacenar dentro de la base de
datos y utilizarlas en conjunto para reconocer a un usuario dado, aumentando
as la robustez del sistema.
Csar Reyes Lpez
Pgina 94

Otras lneas de avance
De la exploracin general del programa de reconocimiento facial

diseado se tiene que el sistema utiliza una sola foto almacenada del usuario
para encontrar una correspondencia con el actual, independientemente de que
se trabaje con la misma foto realzada en paralelo, esto podra mejorarse
teniendo para cada usuario una pequea base de datos propia con multitud de
fotos, distintas posiciones, perfiles, peinados, gafas, y as aumentar la
eficiencia y la dependencia a ciertos aspectos condicionantes a la hora de
reconocer a un sujeto, tenindose en cuenta que al aumentar el nmero de
imgenes del sistema aumenta el tiempo de cmputo, habra que llegar a una
situacin de compromiso.
Otra opcin sera hacer que el usuario gesticulase o hiciera algn tipo de
gesto a la cmara a modo de contrasea, capaz de ser reconocido en directo,
como un guio, una foto de frente y otra de perfil, etc, hechos que aumentasen
la seguridad de que solo un individuo es quien parece ser. De este modo no
podra intentarse vulnerar la seguridad del sistema por ejemplo, presentando
una foto de la cara del usuario frente a la cmara o ponindose una careta con
el rostro del usuario a suplantar.
El contenido de la informacin y las fotografas de la base de datos se
encuentran disponibles, sera importante desarrollar algn tipo de sistema de
encriptado o cifrado de la informacin de los ficheros de texto y de proteccin
de acceso a la base de datos con la imgenes de las caras. De tal forma que la
informacin solo estuviese disponible para el programa principal y durante los
momentos estrictamente necesarios. Podra establecerse un sistema de
contraseas particulares para los usuarios del sistema, cuando quisieran
modificar sus caras de las base de datos o ampliar la misma o incluso para
restringir temporal o permanentemente el acceso a determinados sujetos.
Csar Reyes Lpez
Pgina 95

Resumen
Existen
diferentes
mejoras
aplicables
al
sistema
diseado,
independencia de las condiciones de iluminacin, independencia frente a la

posicin y orientacin, contrasea gesticular, encriptacin de datos e
informacin y cualquier otra que pudiera surgir del estudio del sistema de
reconocimiento facial.
Al ser este un proyecto perteneciente al entorno de seguridad de un
sistema domtico, las lneas de avance, deberan centrarse en mejorar la
robustez e invulnerabilidad.
Csar Reyes Lpez
Pgina 96

6. BIBLIOGRAFA
[1]
Rafael C. Gonzlez. Richard E. Woods. Digital Image Processing.

Ed. Addison-Wesley
[2]
Daro Maravall Gmez-Allende. Reconocimiento de Formas y Visin

Artificial. Ed. RA-MA
[3]
Sing Tze Bou. Pattern Recognition and Image Preprocessing. Ed.

Marcel Dekker, Inc.
[4]
Kiyoharu Aizawa, Katsuhiko Sakaue, Yasuhito Suenaga. Image

Processing Technologies. Algorithms, Sensors, and Applications. Ed.
Marcel Dekker, Inc.
Programacin
[5]
Beck Zaratian. Microsoft Visual C++ 6.0 Manual del Programador.

Ed. Mc Graw Hill
Csar Reyes Lpez
Pgina 97

[6]
Al Stevens, Clayton Walnum. Programacin con C++. Ed. ANAYA

MULTIMEDIA
[7]
Bjarne Stroustrup. El Lenguaje de Programacin C++. Ed Addison

Wesley
[8]
Fco. Javier Ceballos. Programacin Orientada a Objetos con C++.

Ed. RA-MA
OpenCV
[9]
http://www.intel.com/software/products/ipp/index.htm
[10]
http://sourceforece.net/projects/opencvlibrary
[11]
http://groups.yahoo.com/group/OpenCV
PCA y Eigenfaces
[12]
Instituto Universitario de Tecnologa del Conocimiento. Universidad

Complutense de Madrid
http://sirio.psi.ucm.es/PROYECTOS/EIGENCAR/eiweb2.html
[13]
Departamento de Ingeniera Elctrica. Universidad McGill. McGill

Center For Intelligent Machines.
http://www.cim.mcgill.ca/~wsum/sa/proyect/report.html
[14]
Universidad de California. San Diego
http://ai.ucsd.edu/Tutorial/matlab.html#eigenfaces
[15]
Instituto Tecnolgico de Hermosillo. Departamento de Sistemas y

Computacin
http://ith.mx/revista_espacio_ith/numero_2/r02_rostros.htm
Csar Reyes Lpez
Pgina 98

[16]
www.facedetection.com
FFT y correlacin de imgenes

[17]
www.kranf.tk
Redes Neuronales
[18]
Universidad de Chicago
http://people.cs.uchicago.edu/qingj/thesisHtml/
Visin Artificial
[19]
Centro de visin por computador. Universidad Autnoma de

Barcelona
http://www.cvc.uab.es/~joans/webaerfai/visind.html
[20]
Universidad Carlos III de Madrid
http://www.uc3m.es/uc3m/dpto/IN/dpin04/vision.html
[21]
Grupo de Visin y Modelado. Massachussets Institute of Technology
http://web.mit.edu/
[22]
Instituto Tecnolgico de Georgia
http://www.gatech.edu
Enlaces de inters
[23]
Biometra
http://www.biometrics.org
Csar Reyes Lpez
Pgina 99

[24]
Extraccin de caractersticas
http://www.geocities.com/facerecognition/
[25]
Tu cara no es un cdigo de barras

http://lists.jammed.com/RRE/2001/09/0005.html
[26]
Fallos Drsticos
http://www.notbored.org/face-misrecognition.html
Csar Reyes Lpez
Pgina 100

7. ANEXOS
7.1. GUIA DE USUARIO
Para poder ejecutar el programa diseado de reconocimiento facial han
de cumplirse ciertos requisitos tcnicos, tanto a nivel de hardware como de
software ( ver seccin 3, componentes del sistema ).
En cuanto al hardware necesario, se precisa de un ordenador personal,
de caractersticas similares o superiores al utilizado para el desarrollo del
sistema, si se quiere que los tiempos de procesado permanezcan parecidos o
inferiores a los mostrados, y una cmara web correctamente instalada con los
drivers que se adjuntan con la misma.
En cuanto al software, el sistema operativo requerido puede variar,
siempre que permanezca dentro de la familia de Microsoft Windows
(95/98/NT/2000/XP). Se necesita tambin la librera OpenCV, que se puede
obtener de forma gratuita [10].
Csar Reyes Lpez
Pgina 101

Pasos a seguir
Instalar una cmara web en el PC, siguiendo los pasos de instalacin

que se indican en las instrucciones de la misma y utilizando el CD con los
drivers del fabricante.
Una vez instalada la cmara web, proceder a instalar el software
OpenCV descargado de [10]. Se tendr un icono como el mostrado a
continuacin, haciendo doble clic sobre el se iniciar el proceso de instalacin,
similar al de cualquier programa de instalacin bajo entorno Windows.
Ilustracin 38: Icono de Instalacin de la librera OpenCV
La ltima versin hasta la fecha es la mostrada en la imagen anterior,

OpenCV beta 4.
Una vez instalada la librera OpenCV, se puede proceder a la ejecucin
del programa de reconocimiento facial diseado. Para ello, y tomado como
referencia la imagen anterior, dentro de la carpeta Ejecutable, se encuentran
varios ficheros, uno de ellos, denominado Reconocimiento_Facial.exe es el
ejecutable creado por el compilador de C++, sin embargo, como al programa
principal hace falta pasarle como parmetro de entrada el fichero de
Csar Reyes Lpez
Pgina 102

entrenamiento, denominado en este caso Face_Training.xml, se ha creado un

fichero especial, denominado Reconocimiento_Facial.cmd que no es ms que
un fichero que ejecuta secuencias de comandos de Windows. En su interior se
ejecuta la siguiente secuencia:
Ilustracin 39: Face_Training.xml
Ilustracin 40: Ejecutar programa de Reconocimiento Facial
Por tanto, para que el programa se inicie correctamente el fichero a

ejecutar es el denominado Reconocimiento_Facial.cmd, sealado en la
ilustracin anterior. Una vez ejecutado, se mostrar la pantalla inicial del
programa, su funcionamiento, est descrito en el apartado 4.3.
Csar Reyes Lpez
Pgina 103

7.2. OBSERVACIONES
A continuacin se detallan algunas observaciones tanto de diseo como
de ejecucin del programa de reconocimiento facial creado.
Para funcionar correctamente el programa necesita de unos

ficheros y carpetas auxiliares incluidos todos en una misma
carpeta. El fichero ejecutable (*.exe) necesita ser llamado junto con
el fichero de entrenamiento (*.xml), en este caso se ha propuesto la
opcin de usar un fichero .cmd que realice esa llamada. La
ejecucin del programa hace uso de un fichero de texto
denominado caras.txt donde se almacenaran el nmero y nombre
de los usuarios por lo que en una primera ejecucin, si no se tiene,
ha de crearse e introducirse en su interior el valor 00, ningn
usuario en la base de datos. De igual manera ha de crearse una
carpeta denominada caras donde se irn almacenando las fotos
de
los
nuevos
values_norm.txt
usuarios.
no
es
Los
ficheros
necesario
values.txt
crearlos,
se
crean
automticamente en cada ejecucin del programa.
El nmero mximo de usuarios, caras dentro de la base de datos,

que admite el sistema es de 99. Esta ha sido una consideracin de
diseo para facilitar la implementacin del sistema, ya que se ha
supuesto que el nmero de usuarios del sistema no sera elevado,
evitndose as la reserva innecesaria de recursos del sistema y
simplificando funciones tales como almacenar las fotos en la
carpeta de fotos y aumentar y obtener el nmero de usuarios del
sistema del fichero caras.txt.
Si no se instalan correctamente los drivers de la cmara web, el

programa, al iniciarse, mostrar un mensaje de error de libreras.
Si la cmara web se encuentra desconectada o se desconecta

durante la ejecucin del mismo, el programa, al tomar una imagen
indicar como mensaje de error que no se ha detectado una cara,
Csar Reyes Lpez
Pgina 104

ya que no se dispone de ninguna imagen de usuario a la que

detectar una cara.
Para poder congelar una imagen proveniente de la cmara web,

tanto para el caso de nuevo usuario como de reconocimiento,
cuando se pulse una tecla la pantalla con la imagen debe estar
activa.
Cada vez que el programa vuelve a la pantalla de inicio, los

ficheros de texto ya han sido actualizados, por lo que pueden
abrirse y estudiarse sin necesidad de terminar con la ejecucin del
programa principal.
Para una ejecucin ms rpida del programa se recomienda no

mostrar las imgenes de los procesos intermedios que realiza la
funcin compara: imgenes de la base de datos en gris,
imgenes realzadas, eigenfaces. Tambin, suprimir la impresin en
los
ficheros
de
texto
auxiliares
de
la
descomposicin
normalizacin de valores.
Csar Reyes Lpez
Pgina 105

7.3. CDIGO FUENTE

Listado del cdigo fuente del fichero Reconocimiento_Facial.cpp
///////////////////////////////////////////////////////////////////////////////
//
//
//
//
//
CSAR REYES LPEZ
//
// ESCUELA SUPERIOR DE INGENIROS
//
//
MAYO 2005
//
//////////////////////////////////////////////////////////////////////////////
//
Libreras de C++
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <cmath>
#include <string.h>
#include <ctime>
//
Libreras de OpenCV
#include "cv.h"
#include "highgui.h"
#include "cvaux.h"
#include "cvcam.h"
#include "cvtest.h"
//
Variables globales
char persona[50];
// Almacena el nombre del nuevo usuario
char num[61]="0123456789";
// Variable para indexar las caras
int e_cara=0;
// Error si no se encuentra cara (e_cara = 1)
char error[80]="Error. No se ha encontrado una cara...";
//
DECLARACIN DE FUNCIONES
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
void extract_and_norm( IplImage* image, CvRect face_rect ,int scale);
/////////////////////////////////////////////////////////////////////////////////
CvHaarClassifierCascade* load_object_detector( const char* cascade_path )
{
return (CvHaarClassifierCascade*)cvLoad( cascade_path,NULL,NULL,NULL );
}
/////////////////////////////////////////////////////////////////////////////////
void detect_and_draw_objects( IplImage* image,
CvHaarClassifierCascade* cascade,
int do_pyramids );
/////////////////////////////////////////////////////////////////////////////////
IplImage* camara_y_foto(CvCapture* capture);
/////////////////////////////////////////////////////////////////////////////////
int almacena(void);
Csar Reyes Lpez
Pgina 106

/////////////////////////////////////////////////////////////////////////////////
void guarda_foto(int ,IplImage* );
/////////////////////////////////////////////////////////////////////////////////
int compara(IplImage*);
/////////////////////////////////////////////////////////////////////////////////
void realce_mono(void );
/////////////////////////////////////////////////////////////////////////////////
void parecido(int );
/////////////////////////////////////////////////////////////////////////////////
void guardian(int resultado);
/////////////////////////////////////////////////////////////////////////////////
void cvCalcEigenObjects( int nObjects,
void* input,
void* output,
int ioFlags,
int ioBufSize,
void* userData,
CvTermCriteria* calcLimit,
IplImage* avg,
float* eigVals );
/////////////////////////////////////////////////////////////////////////////////
void cvEigenDecomposite( IplImage* obj,
int
nEigObjs,
void* eigInput,
int
ioFlags,
void* userData,
IplImage* avg,
float* coeffs );
/////////////////////////////////////////////////////////////////////////////////
void cvEigenProjection( void* eigInput,
int
nEigObjs,
int
ioFlags,
void* userData,
float* coeffs,
IplImage* avg,
IplImage* proj );
//
DEFINICIN DE FUNCIONES
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// Funcin que recibe la imagen en la que ha de buscarse una cara segn el
// clasificador "cascade" pasado como parmetro
void detect_and_draw_objects( IplImage* image, CvHaarClassifierCascade* cascade,
int do_pyramids )
{
IplImage* small_image = image;
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* faces;
int i, scale = 1;
Csar Reyes Lpez
Pgina 107

if( do_pyramids )
{
small_image = cvCreateImage( cvSize(image->width/2,image->height/2), IPL_DEPTH_8U,
3 );
cvPyrDown( image, small_image, CV_GAUSSIAN_5x5 );
scale = 2;
}
// faces almacena las caras y propiedades de estas detectadas en la imagen
faces = cvHaarDetectObjects( small_image, cascade, storage, 1.1, 2,
CV_HAAR_DO_CANNY_PRUNING ,cvSize(0,0));
// Si no se encuentra ninguna cara, se notifica el error y se sale de la funcin
if ( faces->total == 0 )
{
e_cara=1;
return;
}
// Por cada cara detectada se dibuja un rectngulo alrededor de esta,
// con fines visuales, y se copia su interior a una nueva imagen
// mediante la funcin "extract_and_norm"
for( i = 0; i < faces->total; i++ )
{
CvRect face_rect = *(CvRect*)cvGetSeqElem( faces, i);
extract_and_norm(image,face_rect,scale);
cvRectangle( image, cvPoint(face_rect.x*scale,face_rect.y*scale),
cvPoint((face_rect.x+face_rect.width)*scale,
(face_rect.y+face_rect.height)*scale),
CV_RGB(255,0,0), 2,8,0 );
}
if( small_image != image )
cvReleaseImage( &small_image );
//cvReleaseMemStorage( &storage );
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que extrae la cara de una imagen en la que ya se ha detectado
// y la almacena con un tamao estndar de 128*128 pxeles
void extract_and_norm( IplImage* image, CvRect face_rect ,int scale)
{
int j,k;
CvPoint p = {face_rect.x*scale,face_rect.y*scale};
IplImage* cara = cvCreateImage( cvSize(2*face_rect.width,2*face_rect.height),
IPL_DEPTH_8U, 3 );
IplImage* cara_norm = cvCreateImage( cvSize(128,128), IPL_DEPTH_8U, 3 );
// Se almacena en cara los valores de la cara detectada en la imagen
// Tres niveles, uno por cada valor RGB, rojo, verde y azul.
for (k = 0; k < 2*face_rect.width ; k++)
{
for (j = 0; j < 2*face_rect.height; j++)
{
Csar Reyes Lpez
Pgina 108

((uchar*)(cara->imageData + cara->widthStep*j))[(k)*3] =
((uchar*)(image->imageData + image->widthStep*(p.y+j)))[(p.x+k)*3];
((uchar*)(cara->imageData + cara->widthStep*j))[(k)*3+1] =
((uchar*)(image->imageData + image->widthStep*(p.y+j)))[(p.x+k)*3+1];
((uchar*)(cara->imageData + cara->widthStep*j))[(k)*3+2] =
((uchar*)(image->imageData + image->widthStep*(p.y+j)))[(p.x+k)*3+2];
}
}
cvResize(cara , cara_norm , CV_INTER_LINEAR ); // Redimensiona a 128*128
cvNamedWindow( "Cara de usuario", 0 );
cvShowImage( "Cara de usuario", cara_norm ); // Muestra la cara normalizada
de usuario
cvSaveImage("foto.jpg", cara_norm);
cvReleaseImage( &cara );
cvReleaseImage( &cara_norm );
// Libera memoria, cara y cara_norm
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que accede a la cmara WEB del equipo y realiza la captura
// de una fotografa
IplImage* camara_y_foto(CvCapture* capture)
{
IplImage* image;
IplImage *frame, *frame_copy = 0;
printf("\n Pulse una tecla para fotografiarse... ");
capture = cvCaptureFromCAM(-1);
cvNamedWindow( "Capturando...", 0 );
for(;;) // Visualizacin de la cmara WEB
{
if( !cvGrabFrame( capture ))
break;
frame = cvRetrieveFrame( capture );
if( !frame )
break;
if( !frame_copy )
frame_copy = cvCreateImage( cvSize(frame->width,frame->height),
IPL_DEPTH_8U, frame->nChannels );
if( frame->origin == IPL_ORIGIN_TL )
cvCopy( frame, frame_copy, 0 );
else
cvFlip( frame, frame_copy, 0 );
cvGrabFrame(capture);
image=cvRetrieveFrame(capture);
// Almacena en image cada "frame"
cvShowImage("Capturando...",frame);
if( cvWaitKey( 10 ) >= 0 )
// Sale si se pulsa una tecla
break;
}
cvSaveImage( "captura.jpg", image );
cvDestroyWindow("Capturando...");
Csar Reyes Lpez
// Guarda el resultado como "captura.jpg"
Pgina 109

cvReleaseImage( &frame_copy );
cvReleaseCapture( &capture );
// Libera memoria, frame_copy y capture
return image;
// Devuelve la imagen tomada
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que almacena el nombre del nuevo usuario en el fichero "caras.txt"
// actualizando el nmero de usuarios
int almacena(void)
{
int n_fotos=0;
int n_f[2];
FILE* fichero_out;
if((fichero_out=fopen("caras.txt", "r+")) == NULL)
printf("\n\n\n\t Error abriendo el fichero\n");
rewind(fichero_out);
// Posiciona el puntero al principio del fichero
n_f[0]=getc(fichero_out)-48;
// Obtiene el nmero de usuarios actuales leyendo
// los 2 primeros caracteres del fichero, se convierten
// a entero restando 48 a su valor ASCII.
if (n_f[1]==9)
{
// Aumenta en 1 el nmero de usuarios
n_f[1]=0;
// teniendo en cuenta que se tiene la componente 1 del
n_f[0]++;
// vector n_f para las decenas y la componente 0 para
}
// las unidades
else
n_f[1]++;
fprintf(fichero_out,"%d%d",n_f[0],n_f[1]); // Se escribe el nuevo numero de usuarios
fseek( fichero_out,0, SEEK_END);// Posiciona el puntero al final del fichero
fprintf(fichero_out,"\n");
// Posiciona el puntero en una nueva lnea
fprintf(fichero_out," %s",persona);
// Se escribe el nombre del nuevo usuario
fclose(fichero_out);
// Cierre del fichero
n_fotos=10*n_f[0]+n_f[1];
// Conversin a entero del nmero de usuarios
return n_fotos;
// Retorno del nmero entero de usuarios
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que compara la nueva imagen con las almacenadas anteriormente mediante la
// distancia entre los eigenvectors del subespaciovectorial formado por todas las caras
// de la base de datos.
int compara(IplImage* original)
{
const int n = 100;
// numero de imgenes a usar
const int nEigens = n-1;
// numero de eigenobjects
int i, j, k, numcara, numcara2, numcara_n, numcara_n2, digit = 10;
char foto[30] = "caras/cara00.jpg";
int n_f[2];
char n_fc[2];
double max, max_n, val, val_n, dist, dist_n;
// distancia entre vectores
double menor, menor2, menor_n, menor_n2, umbral, vdist[n], vdist_n[n];
FILE* outFile;
// archivo para resultados
FILE* outFile_n;
// archivo para resultados con realce
CvMemStorage* storage = cvCreateMemStorage(0);
Csar Reyes Lpez
Pgina 110

int n_fotos=0;
FILE* fichero_out;
n_fc[0]=getc(fichero_out);
n_fc[1]=getc(fichero_out);
n_f[0]=n_fc[0]-48;
n_f[1]=n_fc[1]-48;
n_fotos=10*n_f[0]+n_f[1];
n_fotos++;
IplImage* images[n];
// Almacena imgenes de la base de caras
IplImage* images_norm[n];
// Almacena imgenes normalizadas
IplImage* eigens[nEigens];
// eigenobjects
IplImage* eigens_norm[nEigens]; // eigenobjects de las imgenes normalizadas
IplImage* proj[n];
// proyecciones
IplImage* avg;
IplImage* avg_norm;
CvTermCriteria criteria;
float vals[nEigens],vals_norm[nEigens];
// eigenvalues
float coeffs[n][nEigens],coeffs_norm[n][nEigens];// descomposicin de componentes
float normCoeffs[n][nEigens],normCoeffs_norm[n][nEigens];// coeficientes normalizados
if((outFile = fopen("values.txt", "w")) == NULL)
printf(" Error Abriendo fichero\n");
if((outFile_n = fopen("values_norm.txt", "w")) == NULL)
printf(" Error Abriendo fichero\n");
fprintf(outFile, " PROYECTO FIN DE CARRERA \n RECONOCIMIENTO FACIAL \n
CSAR REYES LPEZ \n\n Fichero con valores EIGENFACES\n");
fprintf(outFile_n, " PROYECTO FIN DE CARRERA \n RECONOCIMIENTO FACIAL \n
CSAR REYES LPEZ \n\n Fichero con valores EIGENFACES con Realce\n");
images[0]=cvCreateImage( cvGetSize( original ), IPL_DEPTH_8U, 1 );
cvCvtColor( original, images[0], CV_BGR2GRAY );
proj[0] = cvCreateImage( cvGetSize( images[0] ), IPL_DEPTH_8U, 1 )
cvSaveImage("parecido.jpg",images[0]);
realce_mono();
images_norm[0]=cvLoadImage("realzada.jpg",0);
cvNamedWindow( "imagenes", 0);
cvNamedWindow( "imagenes_norm",0);
cvShowImage( "imagenes", images[0] );
cvShowImage("imagenes_norm",images_norm[0]);
cvWaitKey(0);
j=1;k=0;
for( i=1; i<n_fotos; i++ ){
foto[digit] = num[k];
foto[digit+1] = num[j];
j++;
if ( j==10 )
{
j=0;
k++;
}
Csar Reyes Lpez
// obtiene el nombre de las imgenes
Pgina 111

IplImage* temp = cvLoadImage( foto ); // carga las imgenes
// Se crea una matriz de imgenes y proyecciones
images[i] = cvCreateImage( cvGetSize( temp ), IPL_DEPTH_8U, 1 );
proj[i] = cvCreateImage( cvGetSize( images[0] ), IPL_DEPTH_8U, 1 );
cvCvtColor( temp, images[i], CV_BGR2GRAY );// Escala de grises
cvSaveImage("parecido.jpg",images[i]);
realce_mono();
images_norm[i]=cvLoadImage("realzada.jpg",0);
cvReleaseImage( &temp );
// Libera memoria
cvShowImage("imagenes_norm",images_norm[i]);
cvShowImage( "imagenes", images[i] ); // Muestra las imgenes
cvWaitKey(0);
}
// Prepara para la descomposicin en valores principales
for( i=0; i<n_fotos-1; i++ )
{
eigens[i] = cvCreateImage( cvGetSize( images[0] ), IPL_DEPTH_32F, 1 );
eigens_norm[i] = cvCreateImage( cvGetSize( images_norm[0] ),
IPL_DEPTH_32F, 1 );
}
avg = cvCreateImage( cvGetSize( images[0] ), IPL_DEPTH_32F, 1 );
avg_norm = cvCreateImage( cvGetSize( images_norm[0] ), IPL_DEPTH_32F, 1 );
criteria.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS;
criteria.max_iter = 10;
criteria.epsilon = 0.1;
// ************clculo de eigenobjects & eigenvals************

cvCalcEigenObjects( n_fotos, images, eigens, 0, 0, 0, &criteria, avg, vals );
cvCalcEigenObjects( n_fotos, images_norm, eigens_norm, 0, 0, 0, &criteria, avg_norm,
vals_norm );
fprintf(outFile, "\n Eigenvalues \n" );
// Imprime resultados en el fichero
fprintf(outFile_n, "\n Eigenvalues realce \n" ); // Imprime resultados en el fichero
{
fprintf(outFile, "%15.2lf\n", vals[i] );
fprintf(outFile_n, "%15.2lf\n", vals_norm[i] );
}
// ************clculo descomposicin coeficientes************
fprintf(outFile, "\n Descomposicin en coeficientes \n" );
fprintf(outFile_n, "\n Descomposicin en coeficientes \n" );
for( i=0; i<n_fotos; i++ )
{
cvEigenDecomposite( images[i], n_fotos-1, eigens, 0, 0, avg, coeffs[i] );
cvEigenDecomposite( images_norm[i], n_fotos-1, eigens_norm, 0, 0, avg_norm,
coeffs_norm[i] );
fprintf(outFile, "obj:%d\t", i );
fprintf(outFile_n, "obj:%d\t", i ); // Imprime resultados en el fichero
Csar Reyes Lpez
Pgina 112

for( j=0; j<n_fotos-1; j++ )
{
fprintf(outFile, "%25.2lf", coeffs[i][j] );
fprintf(outFile_n, "%25.2lf", coeffs_norm[i][j] );
}
fprintf(outFile, "\n" );
fprintf(outFile_n, "\n" );
}
// COEFICIENTES NORMALIZADOS
{
max = -100000.00;
max_n = -100000.00;
for( j=0; j<n_fotos; j++ )
{
val = fabs( coeffs[j][i] );
val_n = fabs( coeffs_norm[j][i] );
if( val > max )
max = val;
if ( max == 0 )
max = 0.1;
if( val_n > max_n )
max_n = val_n;
if ( max_n == 0 )
max_n = 0.1;
}
for( j=0; j<n_fotos; j++ ) // Divide por el mximo de todos los coeficientes
{
normCoeffs[j][i]=coeffs[j][i]/max;
normCoeffs_norm[j][i]=coeffs_norm[j][i]/max_n;
}
}
fprintf(outFile, "\n Descomposicin en coeficientes normalizados \n" );
fprintf(outFile_n, "\n Descomposicin en coeficientes normalizados \n" );
{
fprintf(outFile, "obj:%d\t", i );
fprintf(outFile_n, "obj:%d\t", i );
for( j=0; j<n_fotos-1; j++ )
{
fprintf(outFile, "%7.2lf", normCoeffs[i][j] );
fprintf(outFile_n, "%7.2lf", normCoeffs_norm[i][j] );
}
fprintf(outFile, "\n" );
fprintf(outFile_n, "\n" );
}
// PROYECCIONES. Muestra los Eigenfaces
cvNamedWindow( "Eigenfaces", 0 );
Csar Reyes Lpez
Pgina 113

cvEigenProjection( eigens, n_fotos-1, 0, 0, coeffs[i], avg, proj[i] );
{
cvShowImage( "Eigenfaces", proj[i] );
cvWaitKey(0);
}
// DISTANCIA ENTRE VECTORES
// Calcula la distancia entre los eigenvectors, quedndose adems con
// la menor de ellas ( se almacena en la variable "menor" )
double media=0,media_n=0;
{
fprintf(outFile, "\nvector %d\n", i );
fprintf(outFile_n, "\nvector %d\n", i );
for( j=0; j<n_fotos; j++ )
{
dist = 0;
dist_n = 0;
for( k=0; k<n_fotos-1; k++ )
{
dist += fabs( normCoeffs[i][k] - normCoeffs[j][k] );
dist_n += fabs( normCoeffs_norm[i][k] - normCoeffs_norm[j][k] );
}
fprintf(outFile, "%d:\tdist = %10.5lf\n", j, dist );
fprintf(outFile_n, "%d:\tdist_n = %10.5lf\n", j, dist_n );
vdist[j] = dist;
vdist_n[j] = dist_n;
}
if ( i==0 )
{
numcara=0;
numcara_n=0;
menor=vdist[1];
menor_n=vdist_n[1];
j=1;
while ( j < n_fotos )
{
media +=vdist[j];
media_n +=vdist_n[j];
if ( vdist[j] <= menor )
{
menor=vdist[j];
numcara = j;
}
if ( vdist_n[j] <= menor_n )
{
menor_n=vdist_n[j];
numcara_n = j;
}
j++;
}
media = media/(n_fotos-1); media_n = media_n/(n_fotos-1);
umbral=(3+0.15*n_fotos);
// UMBRAL DE DISCERNIMIENTO
Csar Reyes Lpez
Pgina 114

fprintf(outFile,"\n\t Umbral: %2.2lf \n\t Valor menor: %2.2lf \n\t Numero
de cara: %d \n\t Valor medio: %2.2lf \n",umbral,menor,numcara,media);
fprintf(outFile_n,"\n\t Valor menor: %2.2lf \n\t Numero de cara: %d
\n\t Valor medio: %2.2lf \n",menor_n,numcara_n,media_n);
}
if ( i==numcara )
{
numcara2=0;
numcara_n2=0;
menor2=vdist[1];
menor_n2=vdist_n[1];
j=0;
while ( j < n_fotos )
{
if ( vdist[j] <= menor2 && vdist[j] != 0)
{
menor2=vdist[j];
numcara2 = j;
}
if ( vdist_n[j] <= menor_n2 && vdist_n[j] != 0)
{
menor_n2=vdist_n[j];
numcara_n2 = j;
}
j++;
}
fprintf(outFile,"\n\t Valor menor2: %2.2lf \n\t Numero de cara: %d
",menor2,numcara2);
fprintf(outFile_n,"\n\t Valor menor2: %2.2lf \n\t Numero de cara: %d
",menor_n2,numcara_n2);
}
}
umbral=(3+0.15*n_fotos);
// UMBRAL DE DISCERNIMIENTO
if ( menor <= umbral && numcara == numcara_n && numcara2 == numcara_n2 )

{ // Si menor <= umbral, la cara se parece a alguna de las almacenadas con
anterioridad
//printf("\n\n La cara que mas se parece es la numero %d \n\n", numcara);
int porcentaje=(umbral*100-49*menor)/umbral; //
printf("\n\n\t Probabilidad del %d por ciento. \n",porcentaje);
parecido(numcara);
// Muestra por pantalla la cara a la que se parece el
usuario actual
}
else
{
// Si menor > umbral, no se ha encontrado parecido

// entre caras
printf("\n\n\t No se encuentra correspondencia");
numcara=0;
}
// LIMPIEZA DE MEMORIA
{
Csar Reyes Lpez
Pgina 115

cvReleaseImage( &images[i] );
cvReleaseImage( &images_norm[i] );
}
{
cvReleaseImage( &eigens[i] );
cvReleaseImage( &eigens_norm[i] );
}
cvReleaseImage( &avg );
cvReleaseImage( &avg_norm );
cvClearMemStorage( storage );
remove("parecido.jpg");
remove("realzada.jpg");
return numcara;
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que realiza una igualacin de histograma a una imagen
void realce_mono(void)
{
IplImage* imagen;
// almacenar la imagen de entrada
IplImage* imagen2;
// almacenar la imagen de salida
int i,j;
int rows,cols;
rows=128;
cols=128;
uchar matimage [128][128];
// almacenar los datos de las imgenes
int aux;
float aux21;
float x[255];
float hist[255],incre[255],prob[255];
double error;
imagen=cvLoadImage("parecido.jpg",0);
imagen2 = imagen;
// Inicializacin a 0 de los vectores a usar
for (i=0; i<255; i++)
{
hist[i]=0;
prob[i]=0;
x[i]=0;
incre[i]=1;
}
error = 0.00196;
// error = 1/(2x255), mitad de un intervalo de cuantificacin
// Extrae los datos de cada pxel de la imagen de entrada y rellena el vector

// histograma, almacenando para cada una de sus componentes (0,255), el numero
// de pixeles que tienen ese valor
for (i=0; i<rows; i++)
{
for (j=0; j<cols; j++)
{
Csar Reyes Lpez
Pgina 116

matimage[i][j] = ((uchar*)(imagen->imageData + imagen->widthStep*j))[i];
aux = matimage[i][j];
hist[aux] = hist[aux]+1; // Histograma
}
}
prob[0] = hist[0]/(rows*cols); // Histograma normalizado, respecto al numero total de pxeles
for (i=0; i<255; i++)
{
prob[i+1] = prob[i] + hist[i+1]/(rows*cols); // Suma de probabilidades de la imagen
x[i] = i;
x[i] = x[i]/255;
}
// Bucle que realiza la igualacin, mediante la cuantificacin de 'prob' a valores de 'x'
for (i=0; i<255; i++)
{
for (j=0; j<254; j++)
{
aux21 = prob[i];
if ( aux21 <= x[j+1] && aux21 > x[j] + error )
incre[i] = x[j+1];
else if ( aux21 >= x[j] && aux21 <= x[j] + error )
incre[i] = x[j];
}
}
// Bucle que modifica los pxeles de la imagen segn el realce anterior
for (i=0; i<rows; i++)
{
for (j=0; j<cols; j++)
{
aux=matimage[i][j];
((uchar*)(imagen2->imageData + imagen2->widthStep*j))[i] = (incre[aux]*255);
}
}
cvSaveImage("realzada.jpg",imagen2); // Guarda la imagen realzada
cvReleaseImage( &imagen2 );
// Libera memoria
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que muestra por pantalla la cara a la que el usuario actual se parece
void parecido(int numcara)
{
char nombre_cara[20]="caras/cara00.jpg";
int i,n_f[2];
IplImage* parecido;
n_f[0]=0;
n_f[1]=0;
for (i = 1 ; i <= numcara ; i++)
{
Csar Reyes Lpez
Pgina 117

if (n_f[1]==9)
n_f[1]=0;
n_f[0]++;
}
else
n_f[1]++;
// Aumenta en 1 el nmero de usuarios

// teniendo en cuenta que se tiene la componente 1 del
// vector n_f para las decenas y la componente 0 para
// las unidades
}
nombre_cara[10]=num[n_f[0]];
parecido=cvLoadImage(nombre_cara,1);
cvNamedWindow( "Parecido", 0);
cvShowImage( "Parecido", parecido);
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin que guarda la foto de la cara del nuevo usuario dentro de la carpeta "caras"
// del directorio de trabajo y escribe su nombre al final del fichero "caras.txt"
void guarda_foto(int n_foto,IplImage* cara)
{
char nombre_cara[20]="caras/cara00.jpg";
int n_f[2];
FILE* fichero_out;
// Obtiene el nmero de usuarios
// Cierra el fichero
nombre_cara[11]=num[n_f[1]]; // Guarda la foto como caraXX.jpg,
cvSaveImage(nombre_cara,cara);
// con XX el n de usuario
}
/////////////////////////////////////////////////////////////////////////////////
// Funcin segn el resultado devuelto por la funcin "compara", 0 si no se
// ha encontrado correspondencia entre caras o el nmero de la cara a la que
// se parece el usuario actual, deniega o permite el acceso al sistema,
// como forma de validar la permanencia o no al grupo cerrado de usuarios
void guardian(int resultado)
{
FILE* pf;
int i,au=0;
char nombre[60];
if (resultado == 0)
// No se encontr correspondencia entre caras
{
printf("\n\n\n\t ACCESO DENEGADO !!! \n");
}
else
// Se encontr correspondencia con la cara "resultado"
{
printf("\n\n\n\t ACCESO PERMITIDO !!! \n");
pf=fopen("caras.txt","r");
// Se busca su nombre en el fichero "caras.txt"
au=fgetc(pf);
// Y se muestra por pantalla
Csar Reyes Lpez
Pgina 118

au=fgetc(pf);
for (i=0;i<resultado+1;i++)
{
fgets(nombre,61,pf);
au=fgetc(pf);
}
printf("\n\n\t NOMBRE DE USUARIO: %s ",nombre);
fclose(pf);
// Cierre del fichero
cvWaitKey(5000);
// Margen de 5 segundos
}
}
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// PROGRAMA PRINCIPAL (Recibe como parmetro de entrada el tipo de detector facial)
void main(int argc, char** argv )
{
clock_t start,finish;
time_t ltime1, ltime2;
double duracion;
char opt='0';
while ( opt != '2' )
{
// Variable para la opcin a elegir:

// Nuevo usuario, Reconocimiento o Salir
// Bucle infinito hasta que se desee Salir
int resultado,n_fotos,usuarios;
e_cara=0;
IplImage* image;
CvCapture* capture = 0;
CvHaarClassifierCascade* cascade;
cascade = load_object_detector(argv[1]);
// Carga el tipo de detector que
se utilizar
int n_f[2];
FILE* fichero_out;
usuarios=10*n_f[0]+n_f[1];
system("cls");
printf("\n \t RECONOCIMIENTO FACIAL \n\t=======================");
printf("\n\n \t ( El numero actual de usuarios es %d )\n",usuarios);
printf("\n \t Elija una opcion:");
printf("\n\n\t 0 - Nuevo Usuario \n\n\t 1 - Reconocimiento \n\n\t 2 - Salir\n\n ");
printf("\t Opcion: ");
Csar Reyes Lpez
Pgina 119

opt = getchar();
if ( opt != '0' && opt != '1' && opt != '2')
{
// Carcter introducido incorrecto
printf("\n\t ERROR INTRODUCIENDO OPCION, VUELVA A
INTENTARLO\n");
getchar();
cvWaitKey(20000);
opt = '0';
}
else if( opt == '0' )
// NUEVO USUARIO
{
image=camara_y_foto(capture);
// Fotografa al usuario
printf("\n\n\t Introduzca su nombre: ");
getchar();
gets(persona); // Obtiene el nombre del nuevo usuario
cvNamedWindow(persona,0);
image=cvLoadImage("captura.jpg",1);
cvShowImage(persona,image);
detect_and_draw_objects( image, cascade, 1 ); // Detecta cara
if (e_cara == 1) // Error si no se detect una cara
{
printf("\n\n\t %s ",error);
getchar();
cvWaitKey(20000);
opt = '0';
}
else
{
image=cvLoadImage("foto.jpg",1);
n_fotos=almacena();
guarda_foto(n_fotos,image);
// Guarda la foto de la
cara del nuevo usuario
}
}
else if ( opt == '1' )
// RECONOCIMIENTO (ADMISIN Y PROHIBICIN)
{
time( &ltime1 );
start = clock();
image=camara_y_foto(capture);
// Fotografa al usuario
image=cvLoadImage("captura.jpg",1);
detect_and_draw_objects( image, cascade, 1 ); // Detecta cara
if (e_cara == 1) // Error si no se detect una cara
{
printf("\n\n\t %s ",error);
getchar();
cvWaitKey(20000);
opt = '0';
}
else
{
image=cvLoadImage("foto.jpg",1);
Csar Reyes Lpez
Pgina 120

resultado=compara(image);
// Compara la caras con
las ya almacenadas
finish = clock();
time( &ltime2 );
duracion=(double)(finishstart)/(4*CLOCKS_PER_SEC);
printf("\n\n\t El tiempo de computo ha sido de %2.2f
segundos",duracion);
ltime1=ltime2-ltime1;
//printf("\n\n\t El tiempo de computo ha sido de %ld
segundos",ltime1/2);
guardian(resultado);
// Permite o Prohbe su
acceso al sistema
}
}
else if ( opt == '2' ) break;
// SALIR
cvWaitKey(50000);
cvDestroyAllWindows();
remove("foto.jpg");
remove("captura.jpg");
getchar();
cvWaitKey(50000);
cvReleaseImage( &image );
cvReleaseCapture( &capture );
// Espera 5 segundos
// Elimina todas las ventanas
// Borra las imgenes auxiliares
// foto.jpg y captura.jpg
// Libera Memoria
Csar Reyes Lpez
Pgina 121

7.4. FICHEROS DE TEXTO

Listado
del
contenido
de
los
ficheros
de
texto
values.txt
values_norm.txt, ficheros auxiliares donde se almacenan los datos del clculo

de los eigenfaces durante la funcin compara.
Values.txt
CSAR REYES LPEZ
Fichero con valores EIGENFACES
Eigenvalues
276643424.00
90795416.00
70827096.00
45871056.00
29464750.00
21049240.00
18884512.00
13447379.00
11379546.00
10232866.00
9114698.00
8132417.00
7454481.00
6860928.50
6264014.00
5376627.00
5219525.00
4661515.50
3997376.75
3565990.25
3056637.00
Descomposicin en coeficientes
obj:0
0.00
-0.00
-0.00
obj:1
0.00
0.00
0.00
obj:2
-0.00
-0.00
-0.00
obj:3
-0.00
0.00
0.00
obj:4
0.00
-0.00
-0.00
obj:5
-0.00
-0.00
-0.00
obj:6
0.00
4246.69
0.00
0.00
377.80
0.00
0.00
-2283.68
0.00
-0.00
366.34
-0.00
0.00
-686.90
0.00
0.00
0.00
0.00
-0.00
0.00
-0.00
1528.90
-0.00
-0.00
-341.58
-0.00
0.00
438.55
0.00
0.00
-519.34
-0.00
-0.00
0.00
0.00
0.00
-0.00
-0.00
-1903.03
-0.00
0.00
2036.45
-0.00
-0.00
1277.08
-0.00
0.00
696.29
0.00
0.00
0.00
-0.00
-0.00
0.00
-0.00
777.80
-0.00
-0.00
708.89
-0.00
0.00
1635.60
-0.00
-0.00
1837.27
0.00
-0.00
0.00
0.00
0.00
0.00
0.00
174.85
0.00
0.00
-2815.72
0.00
0.00
166.65
-0.00
-0.00
-363.80
0.00
0.00
0.00
0.00
-0.00
0.00
0.00
-1877.30
0.00
-0.00
-1170.77
-0.00
0.00
3108.72
0.00
0.00
0.00
-0.00
0.00
0.00
-1594.67
0.00
-1483.28
-0.00
-1429.08
0.00
0.00
0.00
-3891.74
1872.29
-1154.19
5186.67
3415.82
-1080.41
0.00
-0.00
1133.85
-325.99
0.00
Csar Reyes Lpez
Pgina 122

-0.00
-0.00
obj:7
0.00
-0.00
-0.00
obj:8
-0.00
0.00
0.00
obj:9
-0.00
-0.00
-0.00
obj:10
0.00
0.00
0.00
obj:11
-0.00
0.00
0.00
obj:12
0.00
-0.00
-0.00
obj:13
0.00
-0.00
-0.00
obj:14
0.00
-0.00
0.00
obj:15
0.00
0.00
0.00
obj:16
-0.00
-0.00
-0.00
obj:17
-0.00
-0.00
-0.00
obj:18
0.00
0.00
0.00
obj:19
-0.00
0.00
0.00
obj:20
-0.00
-0.00
-0.00
obj:21
-0.00
-0.00
-0.00
0.00
0.00
-0.00
-0.00
0.00
-0.00
0.00
0.00
-490.55
-0.00
0.00
214.22
0.00
-0.00
2902.36
-0.00
0.00
-1099.92
0.00
0.00
0.00
-0.00
-0.00
0.00
0.00
4339.42
-0.00
-0.00
2435.63
0.00
-0.00
-1003.37
0.00
0.00
-390.77
0.00
-0.00
0.00
-0.00
-0.00
-0.00
-0.00
-1501.96
-0.00
-0.00
-202.90
0.00
0.00
355.39
0.00
-0.00
52.09
-0.00
0.00
0.00
0.00
0.00
-4737.31
-0.00
-0.00
-745.17
-0.00
-0.00
-1011.12
0.00
-0.00
-288.60
0.00
-0.00
-599.33
-0.00
0.00
0.00
0.00
0.00
1482.03
-0.00
-0.00
1495.36
-0.00
0.00
2800.75
0.00
-0.00
1952.07
0.00
-0.00
0.00
-0.00
0.00
0.00
-0.00
-418.27
-0.00
0.00
-429.41
0.00
0.00
468.79
0.00
-0.00
-1699.04
-0.00
0.00
0.00
-0.00
0.00
-0.00
0.00
-1416.03
-0.00
0.00
1529.46
0.00
-0.00
1918.13
-0.00
0.00
-1115.35
0.00
0.00
0.00
-0.00
-0.00
0.00
0.00
576.87
0.00
0.00
-3271.75
0.00
-0.00
-475.53
-0.00
-0.00
532.93
0.00
0.00
0.00
-0.00
-0.00
0.00
-0.00
1238.48
-0.00
-0.00
-354.25
-0.00
0.00
-19.38
0.00
-0.00
200.94
-0.00
-0.00
0.00
0.00
0.00
-1699.35
-0.00
-0.00
1122.25
-0.00
-0.00
-1673.58
0.00
0.00
922.43
-0.00
-0.00
0.00
-0.00
-0.00
2237.13
3393.87
-2952.03
-903.93
0.00
-0.00
-1393.12
3576.40
4833.69
-4936.48
-2312.34
-0.00
-0.00
3613.02
-0.00
-0.00
-3976.29
0.00
-0.00
3394.32
-0.00
-0.00
-1395.39
-0.00
-0.00
-1055.64
0.00
-0.00
0.00
-0.00
-0.00
-5219.13
0.00
-0.00
3335.14
-0.00
-0.00
-1175.32
-0.00
0.00
384.42
0.00
0.00
-943.94
-0.00
-0.00
0.00
-0.00
0.00
2410.59
0.00
0.00
3695.54
0.00
-0.00
2388.28
-0.00
-0.00
-2913.42
-0.00
0.00
193.64
0.00
-0.00
0.00
-0.00
-0.00
-0.00
-0.00
-700.29
-0.00
-0.00
1491.59
-0.00
0.00
-1039.11
0.00
0.00
33.78
-0.00
-0.00
0.00
-0.00
0.00
-0.00
-0.00
-3269.53
-0.00
0.00
-1458.73
0.00
0.00
-1251.64
-0.00
-0.00
372.93
-0.00
0.00
0.00
0.00
-0.00
-3534.58
-4885.16
Descomposicin en coeficientes normalizados

obj:0
0.81 0.09 -0.67 0.13 -0.22 0.00
0.19 0.68 -0.21 -0.06
obj:1
-0.75 0.35 -0.10 0.15 -0.17 0.00
0.65 -0.35 0.41 0.40
obj:2
0.36 -0.44 0.60 0.44 0.22 0.00
0.11 0.10 -0.28 -0.14
obj:3
-0.22 0.18 0.21 0.56 0.59 0.00
-0.65 -0.27 0.11 0.41
obj:4
0.99 0.04 -0.83 0.06 -0.12 0.00
-0.06 0.93 -0.46 -0.21
obj:5
0.65 -0.25 -0.55 -0.40 1.00 0.00
0.19 0.33 0.00 -0.06
Csar Reyes Lpez
0.55 0.18 0.74 0.12 -0.26 0.24 0.00 -0.14 0.49 0.82 -0.10
0.08 0.21 -0.41 -0.20 0.71 -0.59 0.45 0.52 -0.43 -0.20 0.99
-0.46 -0.44 -0.34 -0.04 -0.40 0.46 -0.23 -0.39 -0.40 0.14 -0.68
-0.11 0.54 -0.36 -0.20 -0.00 0.60 0.15 0.25 -0.37 -0.30 0.05
0.31 0.42 0.87 0.09 -0.35 0.55 0.05 -0.72 0.71 0.96 0.03
-0.34 0.01 0.85 0.04 -0.36 0.47 -0.26 -0.20 -0.30 0.26 -0.24
Pgina 123

obj:6
0.22 -0.08 -0.47
-0.35 0.55 -0.13 -0.17
obj:7
0.43 -0.11 0.06
0.34 0.93 -0.35 -0.10
obj:8
0.65 1.00 0.72
1.00 -0.42 -0.26 0.55
obj:9
-0.57 -0.35 -0.06
-0.74 0.08 0.45 -0.58
obj:10
-0.91 -0.17 -0.30
-0.59 0.03 0.64 0.20
obj:11
-0.17 0.34 0.44
-0.41 -0.25 0.12 0.43
obj:12
-0.27 -0.10 -0.13
-0.48 0.00 0.31 -0.70
obj:13
0.69 -0.33 0.45
0.31 1.00 -0.51 -0.53
obj:14
0.93 0.13 -0.96
-0.06 0.70 -0.24 0.17
obj:15
-0.95 0.29 -0.10
-0.31 -0.57 0.76 0.65
obj:16
-0.44 -0.39 0.33
0.10 -0.92 -0.21 -0.25
obj:17
0.69 -0.92 1.00
-0.23 -0.97 -0.73 -0.69
obj:18
-1.00 0.77 -0.35
0.57 -0.90 1.00 1.00
obj:19
0.46 0.85 0.70
0.94 -0.60 -0.50 0.39
obj:20
-0.68 -0.16 0.44
0.10 -0.42 0.19 -0.22
obj:21
-0.94 -0.75 -0.43
-0.62 0.35 -0.09 -0.46
vector 0
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
-0.51 -0.46 0.00 0.22 0.21 0.43 0.08 -0.16 0.15 0.03 -0.20 0.48 0.84 -0.09
1.00 -0.35 0.00 0.69 0.18 -0.29 0.28 -0.30 0.40 -0.19 -0.40 0.25 1.00 -0.02
-0.34 -0.13 0.00 -0.35 0.72 -0.29 0.03 0.05 0.31 -0.35 0.72 1.00 -0.43 -0.50
0.12 0.02 0.00 -0.04 -0.21 -0.31 0.28 0.21 -0.28 0.55 -0.50 -0.39 -0.06 0.40
-0.10 -0.19 0.00 0.26 -1.00 -0.37 0.22 0.62 -0.69 0.79 0.69 -0.43 -0.02 -0.23
0.96 0.63 0.00 -0.18 0.67 -0.38 -0.15 0.02 0.60 -0.02 0.77 -0.39 -0.47 0.20
0.16 -0.55 0.00 0.17 0.13 -0.43 1.00 0.17 -0.27 -0.19 -0.62 -0.10 0.08 0.56
0.66 -0.36 0.00 0.33 -0.10 -0.35 0.06 -0.47 0.63 -0.19 -0.59 0.70 0.52 -0.35
-0.16 0.17 0.00 0.52 0.13 0.78 0.12 -0.20 0.24 -0.02 -0.15 0.68 0.88 -0.14
-0.01 0.06 0.00 0.26 0.23 -0.40 -0.02 0.62 -0.69 1.00 1.00 -0.40 -0.28 0.78
-0.57 0.30 0.00 -0.42 -0.05 -0.11 -0.55 0.13 -0.67 -0.54 -0.33 -0.44 -0.75 -0.51
-0.48 -0.34 0.00 -1.00 -0.93 1.00 -0.55 -1.00 0.88 -0.90 -0.87 -0.00 -0.77 -0.98
0.13 -0.30 0.00 0.76 0.01 -0.38 -0.43 0.98 -0.66 -0.14 0.80 -0.44 -0.73 1.00
-1.00 0.06 0.00 -0.76 0.09 0.44 -0.08 -0.08 0.05 -0.54 0.58 0.99 -0.67 -0.42
0.00000
12.94919
9.66863
11.58117
3.61426
6.32508
3.71048
5.39849
11.92512
11.72295
13.12566
13.03500
10.75858
7.19925
2.16778
14.84009
13.48694
16.27687
15.99594
12.48253
13.61623
11.95634
Umbral: 6.30
Valor menor: 2.17
Numero de cara: 14
Valor medio: 10.56
vector 1
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
12.94919
0.00000
12.69613
8.00964
15.47850
13.67810
12.75774
13.36119
11.63646
7.76151
7.11582
8.69892
9.07186
Csar Reyes Lpez
-0.36 0.01 0.00 -0.41 -0.76 -0.45 -0.47 0.22 -0.73 -0.16 -0.01 -0.48 -0.89 0.10
-0.43 0.12 0.00 -0.08 -0.24 -0.24 0.35 -0.12 -1.00 0.69 -0.20 -0.72 0.08 0.15
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
15.09014
14.26236
4.36961
11.02403
21.17693
5.78515
13.03571
8.44374
10.73376
vector 2
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
9.66863
12.69613
0.00000
8.43922
10.86570
6.67112
9.65750
7.75549
10.44132
8.75424
11.89215
9.21479
10.09999
6.63626
10.51980
14.41563
7.68575
11.73779
16.69207
11.47090
8.63041
10.22205
vector 3
0:
1:
2:
3:
4:
5:
6:
7:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
11.58117
8.00964
8.43922
0.00000
12.46730
9.94053
10.49228
10.83124
Pgina 124

8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
10.19435
8.13004
10.01336
2.46594
9.32477
11.78882
11.71552
8.95250
9.98430
17.19286
12.74928
12.33085
8.98476
10.52743
vector 4
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
3.61426
15.47850
10.86570
12.46730
0.00000
7.95877
5.54571
6.68752
13.48748
12.67613
15.38344
14.01596
11.77251
6.79051
3.62532
16.58861
15.27328
15.62602
19.27382
14.26741
15.50415
13.37245
vector 5
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
6.32508
13.67810
6.67112
9.94053
7.95877
0.00000
6.78956
9.36550
11.84942
10.85041
12.85720
11.13353
11.36228
9.36942
6.72826
15.18974
9.89194
13.48639
17.14562
11.90013
11.01361
9.99877
vector 6
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
3.71048
12.75774
9.65750
10.49228
5.54571
6.78956
0.00000
6.42781
12.08212
9.94540
11.34076
11.99353
Csar Reyes Lpez
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
8.55848
8.13077
4.56688
13.45694
11.48763
15.38145
16.40694
11.84650
11.85733
9.07560
vector 7
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
5.39849
13.36119
7.75549
10.83124
6.68752
9.36550
6.42781
0.00000
12.53686
11.08979
13.86981
11.43781
9.57684
4.67307
7.24771
15.62514
13.21657
17.16808
16.20735
14.13912
13.25436
12.56640
vector 8
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
11.92512
11.63646
10.44132
10.19435
13.48748
11.84942
12.08212
12.53686
0.00000
15.06749
14.78176
9.20854
14.60539
11.59919
12.00250
13.52797
11.43991
15.80908
14.02124
4.77646
11.90848
16.32492
vector 9
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
11.72295
7.76151
8.75424
8.13004
12.67613
10.85041
9.94540
11.08979
15.06749
0.00000
6.50356
10.04262
4.68949
11.25097
12.62831
8.36632
Pgina 125

16:
17:
18:
19:
20:
21:
dist = 9.31630
dist = 17.16030
dist = 12.82465
dist = 16.14863
dist = 7.90980
dist = 5.26598
vector 10
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
13.12566
7.11582
11.89215
10.01336
15.38344
12.85720
11.34076
13.86981
14.78176
6.50356
0.00000
11.21715
9.28934
14.77271
13.47830
5.82343
11.74394
19.59360
10.21389
16.36610
8.46990
7.29541
vector 11
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
13.03500
8.69892
9.21479
2.46594
14.01596
11.13353
11.99353
11.43781
9.20854
10.04262
11.21715
0.00000
10.56504
12.53788
13.12194
9.13282
10.84690
17.82067
12.25994
11.88358
9.46574
12.52894
vector 12
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
10.75858
9.07186
10.09999
9.32477
11.77251
11.36228
8.55848
9.57684
14.60539
4.68949
9.28934
10.56504
0.00000
10.35717
12.09948
10.20409
10.96519
16.99680
12.88283
16.05761
Csar Reyes Lpez
20:
21:
dist =
dist =
9.64181
8.82080
vector 13
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
7.19925
15.09014
6.63626
11.78882
6.79051
9.36942
8.13077
4.67307
11.59919
11.25097
14.77271
12.53788
10.35717
0.00000
8.55487
17.28116
12.63024
13.68640
18.32441
13.12297
13.27581
13.10370
vector 14
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
2.16778
14.26236
10.51980
11.71552
3.62532
6.72826
4.56688
7.24771
12.00250
12.62831
13.47830
13.12194
12.09948
8.55487
0.00000
14.93889
13.69937
16.92466
17.35312
12.11341
14.26276
12.08488
Valor menor2: 2.17

Numero de cara: 0
vector 15
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
14.84009
4.36961
14.41563
8.95250
16.58861
15.18974
13.45694
15.62514
13.52797
8.36632
5.82343
9.13282
10.20409
17.28116
14.93889
0.00000
12.01335
22.07407
6.69735
15.01035
9.80695
10.24616
Pgina 126

vector 16
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
vector 17
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
vector 18
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
13.48694
11.02403
7.68575
9.98430
15.27328
9.89194
11.48763
13.21657
11.43991
9.31630
11.74394
10.84690
10.96519
12.63024
13.69937
12.01335
0.00000
11.45584
12.21015
10.19692
4.79295
9.52257
16.27687
21.17693
11.73779
17.19286
15.62602
13.48639
15.38145
17.16808
15.80908
17.16030
19.59360
17.82067
16.99680
13.68640
16.92466
22.07407
11.45584
0.00000
22.24299
13.55115
13.82103
17.75041
15.99594
5.78515
16.69207
12.74928
19.27382
17.14562
16.40694
16.20735
14.02124
12.82465
10.21389
12.25994
12.88283
18.32441
17.35312
6.69735
12.21015
22.24299
0.00000
14.93323
10.63363
14.85285
Csar Reyes Lpez
vector 19
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
12.48253
13.03571
11.47090
12.33085
14.26741
11.90013
11.84650
14.13912
4.77646
16.14863
16.36610
11.88358
16.05761
13.12297
12.11341
15.01035
10.19692
13.55115
14.93323
0.00000
12.16725
16.76732
vector 20
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
13.61623
8.44374
8.63041
8.98476
15.50415
11.01361
11.85733
13.25436
11.90848
7.90980
8.46990
9.46574
9.64181
13.27581
14.26276
9.80695
4.79295
13.82103
10.63363
12.16725
0.00000
8.70026
vector 21
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
dist =
11.95634
10.73376
10.22205
10.52743
13.37245
9.99877
9.07560
12.56640
16.32492
5.26598
7.29541
12.52894
8.82080
13.10370
12.08488
10.24616
9.52257
17.75041
14.85285
16.76732
8.70026
0.00000
Pgina 127

Values_norm.txt
CSAR REYES LPEZ
Fichero con valores EIGENFACES con Realce
Eigenvalues realce
510668736.00
171120288.00
118985520.00
90055712.00
59504864.00
51875972.00
38113536.00
35950624.00
28586326.00
26743352.00
25320370.00
21452764.00
18641864.00
18234646.00
17308886.00
15243974.00
14319143.00
12291709.00
10812834.00
9182146.00
8615054.00
Descomposicin en coeficientes
obj:0
0.00
0.00
0.00
obj:1
0.00
0.00
-0.00
obj:2
-0.00
0.00
0.00
obj:3
0.00
0.00
0.00
obj:4
0.00
0.00
0.00
obj:5
-0.00
0.00
-0.00
obj:6
0.00
0.00
-0.00
obj:7
-0.00
0.00
0.00
obj:8
-0.00
0.00
0.00
obj:9
0.00
6423.89
0.00
-0.00
-2973.22
-0.00
0.00
-660.99
-0.00
-0.00
784.41
0.00
0.00
-484.69
0.00
-0.00
0.00
-0.00
-0.00
-5635.04
-0.00
-0.00
899.84
-0.00
0.00
-180.34
0.00
0.00
754.74
-0.00
-0.00
1493.81
-0.00
-0.00
-0.00
-0.00
0.00
3171.29
-0.00
-0.00
2273.11
0.00
-0.00
4139.56
-0.00
-0.00
-2425.56
0.00
-0.00
1144.41
-0.00
-0.00
-0.00
-0.00
0.00
-2466.67
-0.00
-0.00
1291.19
0.00
-0.00
1161.83
-0.00
0.00
-1691.28
0.00
-0.00
-3098.54
-0.00
-0.00
-0.00
0.00
-0.00
-3382.12
0.00
0.00
-1796.20
0.00
-0.00
273.13
0.00
0.00
-384.60
0.00
0.00
-0.00
-0.00
-0.00
-1786.12
-0.00
-0.00
-5786.41
0.00
0.00
1196.41
0.00
-0.00
-0.00
-0.00
-0.00
0.00
0.00
-2331.90
0.00
-0.00
2258.64
-0.00
0.00
434.90
-0.00
0.00
0.00
-0.00
-0.00
-0.00
0.00
5054.32
0.00
-0.00
1333.32
0.00
-0.00
459.64
-0.00
-0.00
0.00
-0.00
-0.00
0.00
0.00
-0.00
-0.00
-2277.11
0.00
0.00
1698.25
0.00
-0.00
-884.54
-0.00
-0.00
-0.00
-0.00
-0.00
-0.00
-2345.39
0.00
1190.95
-0.00
604.00
-0.00
-2468.73
0.00
0.00
0.00
6118.07
0.00
-0.00
4391.35
-1250.49
-0.00
0.00
1775.30
-0.00
-0.00
-2919.92
0.00
-0.00
3948.24
-889.55
-0.00
-0.00
3765.78
5597.35
-5854.70
Csar Reyes Lpez
Pgina 128

0.00
-0.00
obj:10
-0.00
0.00
-0.00
obj:11
-0.00
0.00
0.00
obj:12
-0.00
0.00
-0.00
obj:13
0.00
0.00
0.00
obj:14
-0.00
0.00
0.00
obj:15
0.00
0.00
-0.00
obj:16
0.00
0.00
-0.00
obj:17
-0.00
0.00
0.00
obj:18
0.00
0.00
-0.00
obj:19
-0.00
0.00
0.00
obj:20
0.00
0.00
-0.00
obj:21
0.00
0.00
-0.00
-0.00
0.00
0.00
-0.00
0.00
0.00
-1792.19
0.00
0.00
-289.69
0.00
-0.00
920.91
-0.00
-0.00
-27.77
0.00
0.00
0.00
0.00
0.00
2544.01
-0.00
-0.00
2532.75
0.00
0.00
-1923.54
0.00
-0.00
-2730.52
0.00
-0.00
-0.00
0.00
0.00
0.00
-0.00
-1480.22
-0.00
0.00
817.03
0.00
-0.00
2745.87
-0.00
-0.00
3865.22
-0.00
0.00
0.00
-0.00
0.00
-0.00
-0.00
-580.75
-0.00
0.00
4419.38
-0.00
-0.00
1289.16
0.00
-0.00
-184.65
-0.00
-0.00
0.00
-0.00
-0.00
0.00
0.00
-3600.10
-0.00
0.00
-2598.27
-0.00
-0.00
-711.09
0.00
0.00
-851.75
0.00
-0.00
0.00
-0.00
-0.00
-6401.65
-0.00
-0.00
650.80
0.00
0.00
-812.01
0.00
0.00
-276.36
-0.00
-0.00
530.61
-0.00
-0.00
-0.00
0.00
0.00
-2722.32
-0.00
0.00
932.44
0.00
0.00
-1514.95
0.00
-0.00
-4037.52
0.00
0.00
2717.94
-0.00
-0.00
-0.00
0.00
0.00
3312.28
-0.00
-0.00
757.08
-0.00
-0.00
1503.37
0.00
-0.00
932.72
-0.00
-0.00
-0.00
-0.00
-0.00
0.00
-0.00
814.91
0.00
0.00
-977.47
0.00
0.00
954.97
-0.00
-0.00
519.53
-0.00
0.00
0.00
0.00
0.00
0.00
0.00
5422.17
-0.00
-0.00
-4212.19
0.00
0.00
1603.80
0.00
0.00
-1333.80
-0.00
-0.00
-0.00
-0.00
-0.00
-5108.93
-0.00
-0.00
2259.17
0.00
-0.00
-43.64
0.00
0.00
230.96
0.00
-0.00
836.13
-0.00
-0.00
-0.00
0.00
0.00
-5382.45
-0.00
-0.00
-4783.35
0.00
0.00
-592.04
-0.00
0.00
-103.78
-0.00
0.00
-1681.74
0.00
0.00
0.00
0.00
0.00
-6724.55
-0.00
-0.00
-2013.05
-0.00
-0.00
-1921.09
5381.76
6529.32
5324.02
0.00
-0.00
-5649.57
3051.00
Descomposicin en coeficientes normalizados

obj:0
0.96 -0.53 -0.13 0.14 -0.13 0.81
0.89 -0.20 -0.71 0.46
obj:1
-0.84 0.16 -0.04 0.13 0.39 -0.02
-0.47 -0.24 0.50 -0.92
obj:2
0.47 0.41 0.82 -0.42 0.30 -0.35
-0.48 -0.29 0.20 0.85
obj:3
-0.37 0.23 0.23 -0.29 -0.80 -0.16
-0.48 -0.26 -0.05 0.82
obj:4
0.91 -0.60 -0.36 0.05 -0.10 -0.64
1.00 0.15 -1.00 0.59
obj:5
0.65 -0.22 -0.35 -1.00 0.31 -0.71
0.95 -0.18 -0.15 -0.51
obj:6
0.26 -0.52 -0.46 0.39 0.11 0.17
0.99 0.13 -0.02 -0.62
obj:7
0.59 -0.16 1.00 0.23 0.12 1.00
-0.36 -0.03 -0.59 0.76
obj:8
0.56 1.00 -0.45 0.29 -0.23 -0.48
-0.59 -0.73 -0.70 0.36
obj:9
-0.87 -0.42 0.24 0.10 -0.64 0.13
-0.56 1.00 0.82 -0.01
obj:10
-1.00 -0.32 -0.06 0.16 -0.01 0.27
-0.62 0.88 0.85 -0.70
obj:11
-0.30 0.45 0.50 -0.33 -0.71 -0.63
-0.48 -0.52 0.20 0.81
Csar Reyes Lpez
0.11 0.99 -0.50 -0.61 0.46 0.66 -0.62 0.00 -0.25 0.12 -0.83
0.30 -0.20 -0.16 0.23 -0.65 -0.31 -0.04 0.00 -0.23 0.30 0.97
-0.36 -0.50 0.29 -0.04 0.49 -0.01 -0.04 0.00 -0.20 -0.42 -0.15
0.11 -0.51 0.35 -0.08 0.77 -0.17 0.52 0.00 -0.13 -0.34 0.81
0.03 0.75 0.16 0.02 0.34 0.35 -0.53 0.00 -0.16 0.15 -0.62
-0.40 -0.53 -0.24 -0.07 0.41 1.00 -0.36 0.00 1.00 -0.51 -0.38
0.40 0.68 0.03 0.07 -0.52 -0.26 -0.12 0.00 -0.23 0.45 -0.35
-0.01 -0.63 -0.46 0.16 0.13 -0.31 -0.27 0.00 -0.17 0.48 -0.09
-0.82 0.94 -0.58 0.23 0.25 -0.16 -0.04 0.00 0.27 -0.72 0.16
0.17 -0.47 1.00 -0.15 -0.39 0.13 1.00 0.00 -0.19 0.58 0.49
-0.07 -0.23 0.48 0.02 -0.78 0.00 0.64 0.00 -0.16 0.39 -0.06
-0.23 -0.56 -0.15 0.05 0.63 0.05 0.37 0.00 -0.12 -0.47 0.32
Pgina 129

obj:12
-0.29 -0.26 0.16
-0.36 0.75 0.64 -0.62
obj:13
0.80 -0.10 0.87
-0.35 -0.44 -0.97 0.83
obj:14
0.97 -0.64 -0.51
0.84 -0.20 -0.41 0.37
obj:15
-0.95 0.12 -0.16
-0.72 -0.08 0.61 -0.48
obj:16
-0.40 0.17 -0.30
0.24 -0.16 0.57 -0.84
obj:17
0.79 0.59 0.15
-0.25 -0.31 -0.41 0.84
obj:18
-0.84 0.15 -0.19
-0.57 0.57 0.72 -0.64
obj:19
0.45 0.97 -0.83
0.84 -0.18 -0.90 0.55
obj:20
-0.76 0.40 -0.01
-0.43 -0.12 0.69 -1.00
obj:21
-0.80 -0.85 -0.12
0.98 0.45 0.10 -0.91
vector 0
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
0.00000
15.14834
13.16237
14.37275
5.25850
11.33809
9.41842
9.62799
11.78378
16.51455
15.53561
14.86766
13.76997
7.63823
3.78821
16.80810
14.77430
9.81923
15.67380
12.26830
15.89394
13.70733
Valor menor: 3.79

Numero de cara: 14
Valor medio: 12.44
vector 1
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
15.14834
0.00000
10.52360
9.23958
14.60626
14.11732
8.64374
10.67288
13.02898
9.11018
6.78933
10.53837
7.31442
12.75605
16.78191
3.81775
8.34165
12.34981
5.70319
14.80091
3.97697
10.58155
vector 2
0:
dist_n = 13.16237
1:
dist_n = 10.52360
Csar Reyes Lpez
0.47 1.00 0.11 -0.19 0.35 -0.50 0.52 -0.56 -0.46 -0.24 0.00 -0.24 0.20 -0.35
0.22 -0.05 0.96 0.21 -0.54 -0.64 -0.28 0.10 -0.14 -0.72 0.00 -0.23 0.36 -0.82
-0.12 -0.22 0.88 -0.04 1.00 -0.04 -0.50 0.44 0.91 -0.58 0.00 0.98 0.07 -0.73
-0.05 0.14 -0.10 0.30 -0.42 0.40 0.23 -1.00 -0.27 0.43 0.00 -0.09 0.03 1.00
-0.70 0.70 -0.54 0.50 -0.63 0.14 0.03 0.13 -0.15 0.42 0.00 0.39 0.11 -0.71
0.26 0.24 -0.29 -0.54 0.41 -0.69 -0.11 0.38 -0.51 -0.92 0.00 -0.24 -0.59 -0.30
0.17 0.13 0.01 0.52 0.16 0.38 0.34 -0.23 -0.55 0.53 0.00 -0.04 0.06 0.04
0.28 -0.35 -0.51 -1.00 0.96 -0.33 0.61 0.21 -0.38 -0.13 0.00 0.38 -1.00 0.61
0.04 0.22 -0.16 0.66 -0.44 0.26 0.33 0.14 -0.17 0.18 0.00 -0.25 -0.03 0.81
-0.02 -0.44 0.26 0.35 -0.58 0.77 -1.00 -0.74 0.75 0.51 0.00 -0.11 0.77 0.19
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
0.00000
5.99733
11.09121
9.72905
12.26408
7.61439
9.74148
12.61407
11.79021
4.70818
12.15377
9.11165
13.78241
10.71050
9.87302
6.82259
11.31807
12.57705
8.96749
15.63207
vector 3
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
14.37275
9.23958
5.99733
0.00000
12.88791
13.38355
13.35125
10.29793
11.67398
9.11823
11.02165
3.86065
13.53619
11.47543
14.96605
7.93460
10.11719
10.24051
9.89815
13.25764
7.43652
12.83300
vector 4
0:
1:
2:
3:
4:
5:
6:
7:
8:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
5.25850
14.60626
11.09121
12.88791
0.00000
9.62315
7.54399
10.48097
10.73210
Pgina 130

9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
15.18969
13.93936
12.67775
13.31029
9.85336
6.42951
14.91564
12.07499
9.59681
13.65290
10.22630
14.18237
13.69493
vector 5
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
11.33809
14.11732
9.72905
13.38355
9.62315
0.00000
10.90655
12.86337
12.62437
17.46439
15.30531
11.82008
14.07886
14.03130
8.96733
14.64634
9.39600
11.20787
15.09789
12.70430
13.76573
14.28588
vector 6
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
9.41842
8.64374
12.26408
13.35125
7.54399
10.90655
0.00000
10.11392
12.37940
12.09015
9.20839
14.32307
7.60692
12.06451
10.23364
10.24348
9.93752
11.65388
8.66750
12.26918
10.54188
9.48185
vector 7
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
9.62799
10.67288
7.61439
10.29793
10.48097
12.86337
10.11392
0.00000
10.92533
12.66779
11.60524
10.10262
10.26251
Csar Reyes Lpez
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
3.98943
11.92362
12.17622
12.81267
8.40724
11.93343
13.16596
11.40077
15.04906
vector 8
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
11.78378
13.02898
9.74148
11.67398
10.73210
12.62437
12.37940
10.92533
0.00000
16.78453
15.43260
9.75362
13.57081
12.13869
12.46419
13.93299
14.01210
7.19424
13.06051
5.06912
12.87795
19.21516
vector 9
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
16.51455
9.11018
12.61407
9.11823
15.18969
17.46439
12.09015
12.66779
16.78453
0.00000
5.04789
10.87369
10.68692
14.36706
17.56236
7.98268
12.57652
16.54593
7.62536
18.93590
9.11359
8.40982
vector 10
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
15.53561
6.78933
11.79021
11.02165
13.93936
15.30531
9.20839
11.60524
15.43260
5.04789
0.00000
11.97113
7.43473
13.94027
16.48231
5.87244
10.09871
Pgina 131

17:
18:
19:
20:
21:
dist_n = 15.09998
dist_n = 4.84685
dist_n = 18.52200
dist_n = 7.83664
dist_n = 8.06388
vector 11
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
vector 12
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
vector 13
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
14.86766
10.53837
4.70818
3.86065
12.67775
11.82008
14.32307
10.10262
9.75362
10.87369
11.97113
0.00000
13.12041
11.40606
15.36266
10.31489
10.13226
9.47184
11.46459
12.38716
9.18510
14.29723
13.76997
7.31442
12.15377
13.53619
13.31029
14.07886
7.60692
10.26251
13.57081
10.68692
7.43473
13.12041
0.00000
12.70440
15.79961
9.72191
10.44536
10.73806
6.95928
15.38944
9.57761
13.54685
7.63823
12.75605
9.11165
11.47543
9.85336
14.03130
12.06451
3.98943
12.13869
14.36706
13.94027
11.40606
12.70440
0.00000
10.89159
14.58733
13.54105
8.02372
14.54440
14.98363
13.49102
Csar Reyes Lpez
21:
dist_n = 16.50626
vector 14
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
3.78821
16.78191
13.78241
14.96605
6.42951
8.96733
10.23364
11.92362
12.46419
17.56236
16.48231
15.36266
15.79961
10.89159
0.00000
17.38830
14.04244
12.02487
16.45505
12.43891
17.01960
14.29668
Valor menor2: 3.79

Numero de cara: 0
vector 15
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
16.80810
3.81775
10.71050
7.93460
14.91564
14.64634
10.24348
12.17622
13.93299
7.98268
5.87244
10.31489
9.72191
14.58733
17.38830
0.00000
8.21569
14.30324
4.67695
15.91357
4.29276
10.02599
vector 16
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
14.77430
8.34165
9.87302
10.11719
12.07499
9.39600
9.93752
12.81267
14.01210
12.57652
10.09871
10.13226
10.44536
13.54105
14.04244
8.21569
0.00000
13.77646
7.90403
15.17009
6.80059
11.88445
Pgina 132

vector 17
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
9.81923
12.34981
6.82259
10.24051
9.59681
11.20787
11.65388
8.40724
7.19424
16.54593
15.09998
9.47184
10.73806
8.02372
12.02487
14.30324
13.77646
0.00000
12.85411
9.65029
12.37356
19.04203
vector 18
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
15.67380
5.70319
11.31807
9.89815
13.65290
15.09789
8.66750
11.93343
13.06051
7.62536
4.84685
11.46459
6.95928
14.54440
16.45505
4.67695
7.90403
12.85411
0.00000
15.48134
5.18235
10.06757
vector 19
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
12.26830
14.80091
12.57705
13.25764
10.22630
12.70430
12.26918
13.16596
5.06912
18.93590
18.52200
Csar Reyes Lpez
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
12.38716
15.38944
14.98363
12.43891
15.91357
15.17009
9.65029
15.48134
0.00000
14.56277
19.17538
vector 20
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
15.89394
3.97697
8.96749
7.43652
14.18237
13.76573
10.54188
11.40077
12.87795
9.11359
7.83664
9.18510
9.57761
13.49102
17.01960
4.29276
6.80059
12.37356
5.18235
14.56277
0.00000
11.14679
vector 21
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
dist_n =
13.70733
10.58155
15.63207
12.83300
13.69493
14.28588
9.48185
15.04906
19.21516
8.40982
8.06388
14.29723
13.54685
16.50626
14.29668
10.02599
11.88445
19.04203
10.06757
19.17538
11.14679
0.00000
Pgina 133

PFC Reconocimiento Facial Mediante VisiÃ N Artificial

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

PFC Reconocimiento Facial Mediante VisiÃ N Artificial

Caricato da

Copyright:

Formati disponibili

DEPARTAMENTO DE INGENIERA DE

PROYECTO FIN DE CARRERA

PROYECTO FIN DE CARRERA

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

ORGANIZACIN DE LA MEMORIA ............................................................................ 9

2. INTRODUCCIN TERICA .................................................... 11

ESTADOS DEL ARTE................................................................................................ 12

MTODO DE TRABAJO ....................................................................................... 13

Basado en Parmetros (LFA) ....................................................................................18

Basado en Redes Neuronales...................................................................................21

Basado en Plantillas ..................................................................................................23

TCNICAS EMPLEADAS .......................................................................................... 25

DETECCIN DE CARAS ...................................................................................... 25

TRABAJO PREVIO: correlacin y FFT......................................................................27

REALCE MEDIANTE IGUALACIN DE HISTOGRAMA ...................................... 36

3. COMPONENTES DEL SISTEMA ............................................ 40

Fuente de iluminacin directa....................................................................................41

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

Fuente de iluminacin arbitraria ................................................................................42

Iluminacin del entorno de trabajo.............................................................................42

CMARA WEB ...................................................................................................... 43

EQUIPO INFORMTICO ...................................................................................... 45

ENTORNO DE PROGRAMACIN ............................................................................ 45

MICROSOFT VISUAL C++ 6.0 ............................................................................. 47

DIAGRAMA DE FLUJO ......................................................................................... 49

ESTRUCTURA INTERNA ..................................................................................... 52

MAIN Funcin principal...........................................................................................52

NUEVO USUARIO ....................................................................................................55

FUNCIONES INTERNAS ...................................................................................... 56

Funciones de librera de C++ ....................................................................................56

Funciones de Librera de OpenCV ............................................................................56

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

Funciones Propias .....................................................................................................64

CRITERIOS PARA EL RECONOCIMIENTO ............................................................. 76

COMPARA. Realce y Eigenfaces.......................................................................... 84

5. CONCLUSIONES Y LNEAS DE DESARROLLO FUTURAS. 91

LNEAS DE DESARROLLO FUTURAS ..................................................................... 92

GUIA DE USUARIO ................................................................................................. 101

CDIGO FUENTE ................................................................................................... 106

FICHEROS DE TEXTO............................................................................................ 122

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

PROYECTO FIN DE CARRERA

en EEUU durante la ltima final de ftbol americano, conocida como Super

reconocimiento, no deberan ser totalmente independientes, debido a que

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

reconocimiento facial proporciona al usuario cierta comodidad con respecto a

1.3. ORGANIZACIN DE LA MEMORIA

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

iniciales del proyecto, tanto para la deteccin como para el reconocimiento de

Csar Reyes Lpez

PROYECTO FIN DE CARRERA

Csar Reyes Lpez

PROYECTO FIN DE CARRERA