MANUAL TÉCNICO

RECONOCIMIENTO FACIAL

UNIVERSIDAD UTE

FACULTAD DE CIENCIAS DE LA INGENIERÍA E INDUSTRIAS

DAVID ESTEBAN GUAJÁN CHÁVEZ

MATEO PAUL ORTEGA VACA

CIENCIAS DE LA COMPUTACION

COMPUTACIÓN GRÁFICA

SEXTO SEMESTRE

QUITO – ECUADOR

2021 – 2022
 Contenido

Contenido ........................................................................................................................................ 2
Presentación .................................................................................................................................... 3
Objetivo ........................................................................................................................................... 4
Procesos........................................................................................................................................... 5
Requisitos del sistema ..................................................................................................................... 6
Herramientas utilizadas para el desarrollo ..................................................................................... 7
Instalación de aplicaciones.............................................................................................................. 8
Métodos y funciones ....................................................................................................................... 9
Conclusiones .................................................................................................................................. 14
 Presentación

El siguiente manual guiará a los usuarios que harán uso de la aplicación desarrollada para la
detección de rostros, el cual dará a conocer los requerimientos y la estructura para la construcción
de la aplicación, dicha aplicación se codificó en el lenguaje de programación Python, con el uso de
algunas de sus innumerables librerías.
 Objetivo

Especificar al usuario el funcionamiento y conformación de la aplicación desarrollada, los métodos

realizados con base a los requerimientos obtenidos, haciendo uso de los diferentes temas vistos a
lo largo de la materia, también se expondrán los diferentes procesos que contiene el aplicativo.
Procesos

Procesos de entrada

• Colocar los videos a analizar en la carpeta principal

• Ingresar a un ejecutor de código Python o CMD
• Modificar el archivo capturandoRostros.py
• Ejecutar el archivo capturandoRostros.py
• Ejecutar el archivo entrenandoRF.py
• Modificar el archivo ReconocimientoFacial.py
• Ejecutar el archivo ReconocimientoFacial.py

Procesos de salida

• Consulta de imágenes generadas

• Consulta de archivo generado
• Visualización de resultado final ReconocimientoFacial.py
Requisitos del sistema

Requerimientos de hardware

• Sistema de 32 o 64 bits.
• Memoria RAM 2.5 GB.
• Resolución mínima del monitor 1024×768 (Recomendada 1920×1080).

Requerimientos de software

• Sistema operativo (Windows 10 en adelante).

• PyCharm Community.
Herramientas utilizadas para el desarrollo

Python

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en la legibilidad

de su código. Se trata de un lenguaje de programación multiparadigma, ya que soporta parcialmente
la orientación a objetos, programación imperativa y, en menor medida, programación funcional.

• Librería OpenCV

Es una enorme biblioteca de código abierto para visión artificial, aprendizaje automático y
procesamiento de imágenes. OpenCV admite una amplia variedad de lenguajes de
programación como Python, C ++, Java, etc. Puede procesar imágenes y videos para
identificar objetos, rostros o incluso la escritura a mano de un ser humano. Cuando se
integra con varias bibliotecas, como Numpy, que es una biblioteca altamente optimizada
para operaciones numéricas, la cantidad de armas aumenta en su arsenal, es decir,
cualquier operación que se pueda hacer en Numpy se puede combinar con OpenCV.

• Librería Numpy

Numpy es un paquete de procesamiento de matrices de propósito general. Proporciona un

objeto de matriz multidimensional de alto rendimiento y herramientas para trabajar con
estas matrices. Es el paquete fundamental para la computación científica con Python.
Además de sus usos científicos obvios, Numpy también se puede utilizar como un
contenedor multidimensional eficiente de datos genéricos.

Pycharm

PyCharm es un entorno de desarrollo integrado utilizado en la programación informática,

específicamente para el lenguaje de programación Python. Está desarrollado por la empresa checa
JetBrains. PyCharm proporciona una finalización del código inteligente, inspecciones del código,
indicación de errores sobre la marcha y arreglos rápidos, así como refactorización de código
automática y completas funcionalidades de navegación.
Instalación de aplicaciones

Python

Se desacargó usando cualquier navegador el ejecutable para la instalación de Python en su versión

más reciente, como cualquier paquete de instalación seguimos las instrucciones de este,
marcaremos las casillas desmarcadas para mayor facilidad a la hora de usar comandos de Python.

Pycharm

Se descargó de igual manera el ejecutable del instalador de la aplicación Pycharm, en este caso se
escogió la versión gratuita del software, después se prosiguió con la instalación.
Métodos y funciones

capturandoRostos.py

Realizamos la importación de las librerías a usar en la aplicación, las cuales fueron opencv-python,
numpy, la librería imutils y la librería por defecto os.

Creamos un directorio con el nombre de la persona que será escaneada para guardar sus datos.

Añadimos una excepción para verificar si dicha carpeta ya existe, si fuera el caso presenta un
mensaje de existencia.

Capturamos la información del video proporcionado por el usuario con el método de la librería
opencv, VideoCapture (). También existe la opción de obtener dicha información de la cámara web
del dispositivo.
Utilizamos el método CascadeClassifier (), el cual es un enfoque basado en el aprendizaje
automático en el que se entrena una función en cascada a partir de muchas imágenes positivas y
negativas. Luego se usa para detectar objetos en otras imágenes. Para usarlo debemos especificar
el archivo a usar en este caso detectara la cara frontal de una imagen proporcionada por defecto.

Definimos un procedimiento While el cual obtendrá los diferentes frames del video ingresado por
el usuario, dicha información ingresada la convertiremos a escala de grises con el método cvtColor()
una vez culminado este proceso copiaremos los frames obtenidos.

El siguiente método usa el parámetro decectMultiScale (), el cual detecta objetos de diferentes
tamaños en la imagen de entrada. Los objetos detectados se devuelven como una lista de
rectángulos. Las imágenes de entrada son nuestros frames transformados a escala de grises, dichos
resultados se guardan una variable.

Con nuestros frames procesados los guardamos como imágenes con el siguiente nombre rostro_#,
dichos rostros se guardarán en el directorio previamente creado, desarrollamos un procedimiento
for para el procesamiento de los diferentes frames y su posterior guardado, en nuestro caso
definimos un if para obtener 300 frames, es muy importante importar la mayor cantidad de datos
para que nuestra aplicación funcioné correctamente, así como lo haría una red neuronal.
entrenandoRF.py

Realizamos la importación de las librerías previamente usadas.

Una vez más usamos el directorio creado en el anterior procedimiento, si encuentra varios
nombres creará una lista con todos los nombres encontrados por el método.
Creamos un for para extraer y procesar las diferentes imágenes que se encuentran en los
directorios creados por el usuario.

Los siguientes métodos crearan el archivo en donde se encuentra toda la información recolectada
previamente por el procedimiento for, para el procesamiento de imágenes usamos un método LBPH
él cual realiza lo siguiente, el área de la cara se divide primero en pequeñas regiones de las que se
extraen los patrones binarios locales (LBP), los histogramas y se concatenan en un solo vector de
características. Este vector de características forma una representación eficiente de la cara y se
utiliza para medir similitudes entre imágenes. Los glóbulos blancos (como los ojos) pesan 4 veces
más que las otras células. Esto simplemente significa que tomamos los histogramas LBP de las
regiones de glóbulos blancos y los multiplicamos por 4 (teniendo en cuenta cualquier
escala/normalización de los histogramas).

Una vez desarrollado todo el proceso guardamos la información procesada en un archivo .xml, el
cual podemos modificar el nombre.
ReconocimientoFacial.py

Realizamos la importación y definición de nuestras carpetas con datos.

Con los métodos previamente definimos cargamos los procesos que se usarán para el
reconocimiento facial, para ello usamos los archivos previamente generados que servirán como
guías para el algoritmo. También proporcionamos el video que se va a analizar.

Generamos un While que con la información proporcionada procesará los datos obtenidos por el
video que ingresamos.
En los siguientes procedimientos es donde se realizará la detección de los rostros, con la información
procesada se definirá cual frame contiene la similitud con nuestro archivo de rostros, si el
cuestionamiento es verídico la aplicación mostrará en un cuadro verde el rostro identificado, así
como su nombre, si no fuera así lo colocará en color rojo con un mensaje de ‘desconocido’.

Conclusiones

Investigar toda la documentación pertinente para la comprensión de los métodos a usar, así como
su correcta implementación y desarrollo.

Utilizar versiones actuales y oficiales de software a usar en el desarrollo de la aplicación, así como
la correcta instalación de las librerías y el uso de sus diferentes métodos.

Desarrollar aplicando los conocimientos compartidos por el docente en las diferentes clases,
analizando las diferentes fuentes bibliográficas.