Integrantes: Marcelo Barahona, Javier Masabanda, Fausto Naranjo, Oscar Rodríguez

NRC: 8940
Fecha: 14-07-2020
Tema: OpenCV y Yolo

Ejercicio 1
Reconocimiento facial y de ojos mediante Open CV
Mediante la librería de Open CV se conseguirá abrir la cámara web de la computadora, y
mediante a esta conseguir que detecte rostros con un rectángulo azul y los ojos de la persona
con un rectángulo verde.

1. Descargar los archivos necesarios para el reconocimiento de la página de Github, en este

caso necesitaremos los archivos haarcascade_frontalface_default.xml y
haarcascade_eye_tree_eyeglasses.xml.
https://github.com/opencv/opencv/tree/master/data/haarcascades

2. Importamos la librería cv2 y los archivos descargados anteriormente que deben estar en la
misma carpeta que el archivo OpenCV.py que estemos creando.

3. Se utiliza el comando “cv2.VideoCapture(0)” para capturar el video de nuestra cámara web

4. Colocamos un ciclo While para mantener abierta la cámara hasta que cerremos el programa
en donde colocaremos todos los comandos necesarios para detectar y dibujar los rectángulos
en la imagen capturada por la webcam.

5. Guardamos los frames capturados por la cámara y los cambiamos de BGR a escala de grises.
6. La parte más importante del programa es esta línea de código, ya que aquí vamos a colocar
los valores que sean más eficientes para detectar los rostros, y que no haya falsos positivos ni
errores en la detección. Al manipular estos valores, podrá detectar más rostros de los que hay
realmente en la imagen o menos rostros de los que debería detectar, por lo cual es importante
que se vaya variando cada uno de los 4 parámetros a conveniencia del programador

7. Dibujamos un rectángulo sobre el rostro y luego dentro del rectángulo dibujado buscamos los
ojos para que mediante un ciclo For dibuje los rectángulos de los ojos.

8. Abrimos la ventana donde se mostrará la imagen de la webcam con los rostros.

9. Colocamos comandos para detener la captura de video en caso se cierre el programa.

Resultado

Fig 1. Resultado del programa en ejecución

Código del Ejercicio 1

#importamos librería OpenCV
import cv2

#Importamos archivos necesarios de cara y ojos que deben estar en la mism

a carpeta que el .py
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml
')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye_tree_eyeglasses.xml'
)
#Capturamos el video de la cámara web
videocamara = cv2.VideoCapture(0)

#Colocamos un ciclo While para mantener abierta la cámara hasta que cerre
mos el programa
while videocamara.isOpened():
#Guarda los frames capturados por la webcam
ret, img = videocamara.read()
#Se transforma la imagen de BGR a escala de grises
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Busca en la imagen el rostro
rostros = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNei
ghbors=10, minSize=(30,30), maxSize=(300,300))

#Dibujamos el rectángulo
for (x, y , w ,h) in rostros:
#Se dibuja el rectángulo
cv2.rectangle(img, (x,y), (x+w, y+h), (255, 0 , 0), 3)
#Selecciona el rostro
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]

#Encuentra los ojos que hay en el rostro

ojos = eye_cascade.detectMultiScale(roi_gray)

#Dibujamos el rectángulo en los ojos

for (ex, ey ,ew, eh) in ojos:
cv2.rectangle(roi_color, (ex,ey), (ex+ew, ey+eh), (0, 255, 0)
, 5)

#Abre la ventana de la cámara web

cv2.imshow('Detector de rostros y ojos', img)

#Cierra la ventana si paramos el video

if cv2.waitKey(1) & 0xFF == ord('q'):
break

#Pausa el video cuando se cierra la ventana

videocamara.release()
cv2.destroyAllWindows()

Ejercicio 2
Guía Ejercicio Implementación de YOLO con Python
1. Instalación de Dependencias:
Las siguientes cosas son necesarias para ejecutar el código que hemos implementado
como ejercicio de aplicación:
 1. Python 3 - Preinstalado
2. Numpy - ejecutamos el comando en la terminal: pip install numpy
3. OpenCV - ingresamos el comando en la terminal: pip install opencv-python

2. Archivos Requeridos:
Para correr el algoritmo necesitamos tener en el mismo directorio de nuestro script (.py)
los 3 archivos siguientes:
2.1. Archivo Weight: es el modelo predefinido, el núcleo del algoritmo para detectar
objetos. Debido a su tamaño se requerirá su descarga desde el siguiente enlace:
https://pjreddie.com/darknet/yolo/
En la sección: “Performance on the COCO Dataset”, el archivo denominado YOLOv3-
416. Debido a que es el formato de imagen blop usado en nuestro programa.
2.2. Archivo Cfg: es el archivo de configuración donde se encuentran todos los ajustes
del algoritmo.
2.3. Nombres de Clase: Archivo de texto donde se listen los nombres de clase.
(coco.names) -contiene el nombre de los objetos que el algoritmo puede detectar.
2.4. Imagen de Entrada – cualquier archivo de imagen (variadas extensiones .jpg, .png,
etc.)
3. Implementando el Código:
3.1. Empezamos importando las librerías Open CV y numpy

3.2. Cargamos el algoritmo de YOLO

3.3. Creamos una matriz para las clases (nombre correspondientes a los objetos que va
a detectar Python), podemos enumerarlas directamente dentro de nuestra variable
Classses, una por una, o importarlas directamente de nuestro archivo de texto
(coco.names) donde están previamente escritas las clases (usaremos esta segunda
opción)

3.4. Para comprobar que nuestro programa lee el archivo coco.names podemos
ejecutar la sentencia:
Obteniendo como resultado una matriz numerando las 80 clases del archivo
coco.names:

Una vez verificado podemos borrar la sentencia print y seguir con nuestro código:

3.5. Procedemos a obtener los nombres de clases que se usaran en los recuadros al
momento de reconocer los objetos en la imagen.

3.6. Cargando nuestra imagen:

Nuestra imagen de entrada es la siguiente:

Fig 2. Figura de Muestra 1

Primero definimos nuestra variable imagen como img y accedemos a los comando de
lectura (comando - imread) de open cv.

Antes de seguir con el código verificaremos que el programa puede leer nuestra
imagen y mostrarla (comando - imshow).
Dependiendo de la resolución de nuestra imagen será necesario redefinir el tamaño de
nuestra imagen mostrada, en nuestro caso el resultado no fue óptimo como se
muestra en la siguiente imagen de salida:

Fig 3. Primer Resultado

Y requerimos redefinir el tamaño mediante la siguiente línea:

Una vez redefinimos el tamaño la imagen de salida quedara definida por:

Fig 4. Segundo Resultado

3.7. Detección de los objetos:
Ahora que tenemos el algoritmo listo para funcionar y también la imagen, es hora de
pasar la imagen a la red y hacer la detección.

Tenga en cuenta que no podemos usar de inmediato la imagen completa en la red,

primero necesitamos convertirla en un blob.
Blob se utiliza para extraer la función de la imagen y cambiar su tamaño. Debido a que
YOLO acepta tres tamaños:

• 320 × 320 es pequeño, así que menos precisión, pero mejor velocidad
• 609 × 609 es más grande, así que alta precisión y velocidad lenta
• 416 × 416 está en el medio y obtienes un poco de ambos

Las salidas de la variable outs son el resultado de la detección. Outs es una matriz que
contiene toda la información sobre los objetos detectados, su posición y la confianza en
la detección.

En este punto, la detección está hecha, y solo necesitamos mostrar el resultado en la

pantalla.
Podemos verificar la detección imprimiendo la variable outs a traves de un print y un
loop for para representar cado objeto detectado.

Fig 5. Detección de clases diferentes en la imagen seleccionada.

Una vez verificada la detección procedemos a borrar el comando print y la sentencia for
que se usaron para verificar la detección.

Luego, recorremos el conjunto de salidas, calculamos la confianza y elegimos un umbral

de confianza.

En la línea 32 establecemos un umbral de confianza de 0,5; si es mayor, consideramos

que el objeto se detectó correctamente; de lo contrario, lo omitimos.
El umbral va de 0 a 1. Cuanto más cercano a 1, mayor es la precisión de la detección,
mientras que cuanto más cercano a 0, menor es la precisión, pero también es mayor el
número de objetos detectados.

Cuando realizamos la detección, sucede que tenemos más cuadros para el mismo objeto,
por lo que debemos usar otra función para eliminar este "problema".
Se llama “Non maximum suppresion”.

Finalmente extraemos toda la información y la mostramos en la pantalla.

• Cuadro (Box): contiene las coordenadas del rectángulo alrededor del objeto
detectado.
• Etiqueta (Label): es el nombre del objeto detectado
• Confianza (Confidence): la confianza sobre la detección de 0 a 1.
El programa final nos arrojara el siguiente resultado:

Fig 6. Resultado Final de la Detección de Objetos.

El resultado impreso en la consola representará el número de objetos detectados por el

algoritmo numerados en un array.

Fig 7. Resultado impreso en la consola.

Código del Ejercicio 2

import cv2
import numpy as np

# Cargando YOLO
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
classes = []
with open("coco.names", "r") as f:
classes = [line.strip() for line in f.readlines()]
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLaye
rs()]
colors = np.random.uniform(0, 255, size=(len(classes), 3))

# Cargando Nuestra Imagen

img = cv2.imread("imagen1.jpg")
img = cv2.resize(img, None, fx=0.3, fy=0.3)
height, width, channels = img.shape

# Detectando Objetos
blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, c
rop=False)

net.setInput(blob)
outs = net.forward(output_layers)

# Mostrar informacion en pantalla

class_ids = []
confidences = []
boxes = []
for out in outs:
for detection in out:
scores = detection[5:]
class_id = np.argmax(scores)
confidence = scores[class_id]
if confidence > 0.5:
# Objeto Detectado
center_x = int(detection[0] * width)
center_y = int(detection[1] * height)
w = int(detection[2] * width)
h = int(detection[3] * height)

# Coordenadas del Rectangulo

x = int(center_x - w / 2)
y = int(center_y - h / 2)

boxes.append([x, y, w, h])
confidences.append(float(confidence))
class_ids.append(class_id)

indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

print(indexes)
font = cv2.FONT_HERSHEY_PLAIN
for i in range(len(boxes)):
 if i in indexes:
x, y, w, h = boxes[i]
label = str(classes[class_ids[i]])
color = colors[i]
cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
cv2.putText(img, label, (x, y + 30), font, 3, color, 3)

cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

EJERCICIO DE DEBER
1. En base al programa anterior, utilizar una imagen de extensión .png más de tres rostros y
ubicarla en la misma carpeta donde se encuentren los otros 3 archivos necesarios para el
ejercicio anterior, y conseguir que ubicar en la imagen los rostros y ojos de todas las personas
de la imagen sin ningún falso positivo ni rostro faltante de detectar.

Nota: Utilizar el comando “cv2.imread('foto.png')” para capturar la imagen de la fotografía

Resultado a obtener en el deber:

Fig 8. Resultado esperado en el deber