Empezando con imágenes

Contenido [ocultar]
o

0.0.1 Metas
 1 Usando OpenCV con imágenes
o 1.1 Leer una imagen
o 1.2 Mostrar una imagen
o 1.3 Guarda una imagen
o 1.4 Resumiendo todo
o 1.5 Usando de Matplotlib

Metas
 Aquí aprenderás cómo leer una imagen, cómo mostrarla y cómo guardarla
de nuevo
 Aprenderás para que sirven las siguientes
funciones: cv2.imread (), cv2.imshow (), cv2.imwrite ()
 Opcionalmente, aprenderás cómo mostrar imágenes con Matplotlib

Usando OpenCV con imágenes

Leer una imagen
Utilizamos la función cv2.imread() para leer una imagen. La imagen debe estar en
el directorio de trabajo o se ha de señalar una ruta absoluta a la imagen.
El segundo argumento es un indicador (o bandera) que especifica la forma en que
se debe leer la imagen.

 cv2.IMREAD_COLOR: carga una imagen de color. Cualquier transparencia de la

imagen será ignorada. Es el indicador (o bandera) predeterminado.
 cv2.IMREAD_GRAYSCALE: carga la imagen en modo de escala de grises
 cv2.IMREAD_UNCHANGED: carga la imagen como sin alteraciones incluyendo el
canal alfa

Nota
En lugar de estos tres indicadores (o banderas), simplemente puedes pasar
números enteros, específicamente 1, 0 o -1, respectivamente.

Mira el siguiente código:

1 import numpy as np
2 import cv2
3 # Load an color image in grayscale
4 img = cv2.imread('58-aprenderpython.jpg',0)
cv2.imshow('image',img)
5
 Advertencia
Incluso si la ruta de la imagen está mal, no lanzara ningún error,
pero print img dará como resultado None

Mostrar una imagen

Utiliza la función cv2.imshow() para mostrar una imagen en una ventana. La
ventana se ajusta automáticamente al tamaño de la imagen.
El primer argumento es un nombre de ventana el cual es una cadena (tipo de dato
string). El segundo argumento es nuestra imagen. Puedes crear tantas ventanas
como desees, pero con nombres diferentes de ventana.

1 cv2.imshow('image',img)
2 cv2.waitKey(0)
3 cv2.destroyAllWindows()

cv2.waitKey () es una función de enlace con el teclado. Su argumento es tiempo

en milisegundos. La función espera durante milisegundos especificados que
suceda cualquier evento de teclado. Si presionas cualquier tecla en ese momento,
el programa continúa. Si se pasa el valor 0, la esperad del evento es indefinida
hasta que se presione una tecla. También se puede configurar para detectar
pulsaciones de teclas específicas, por ejemplo, si se presiona la tecla a tecla, etc,
lo cual veremos más adelante.
cv2.destroyAllWindows() Esta función destruye todas las ventanas que hemos
creado. Si deseas destruir una ventana específica, utilice la función
de cv2.destroyWindow () donde se pasa el nombre de la ventana a eliminar como
argumento.

Nota
Hay un caso especial en que puedes crear una ventana y cargar la imagen
posteriormente. En ese caso, puedes especificar si la ventana es redimensionable
o no. Esto se realiza con la función cv2.namedWindow(). Por defecto, el indicador
(o bandera) es cv2.WINDOW_AUTOSIZE. Pero si se especifica la que el indicador
sea cv2.WINDOW_NORMAL, puedes cambiar el tamaño de la ventana. Esto será
útil cuando las dimensiones de la imagen sean muy grandes y se añada una barra
de seguimiento (o un scroll).

Ve el siguiente código:

1 cv2.namedWindow('image', cv2.WINDOW_NORMAL)
2 cv2.imshow('image',img)
3 cv2.waitKey(0)
4 cv2.destroyAllWindows()
Guarda una imagen
Utiliza la función cv2.imwrite () para guardar una imagen.
El primer argumento es el nombre del archivo y el segundo argumento es la
imagen que deseas guardar.

1 cv2.imwrite('deepgris.png',img)

Esto guardará la imagen en formato PNG en el directorio de trabajo.

Resumiendo todo
A continuación, el programa carga una imagen en escala de grises, la muestra,
guarda la imagen si presionas ‘s’ y termina su ejecución, o simplemente termina
sin guardar si presionas la tecla ESC.

1
2 import numpy as np
import cv2
3
4 img = cv2.imread('58-aprenderpython.jpg',0)
5 cv2.imshow('image',img)
6 k = cv2.waitKey(0)
7 if k == 27: # wait for ESC key to exit
8 cv2.destroyAllWindows()
elif k == ord('s'): # wait for 's' key to save and exit
9 cv2.imwrite('deepgray.jpg',img)
10 cv2.destroyAllWindows()
11

Advertencia
Si está utilizando una máquina de 64 bits, tendrás que modificar la linea k =
cv2.waitKey (0) de la siguiente manera: k = cv2.waitKey (0) & 0xFF
Usando de Matplotlib
Matplotlib es una biblioteca para gráficar en Python que te ofrece una amplia
variedad de métodos para plotear. Los verás en los próximos artículos. Aquí,
aprenderás a mostrar una imagen con Matplotlib. Puede ampliar las imágenes,
guardarlas, etc utilizando Matplotlib.

1
import numpy as np
2 import cv2
3 from matplotlib import pyplot as plt
4
5 img = cv2.imread('58-aprenderpython.jpg',0)
6 plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([]) # to hide tick values on X and Y axis
7
plt.show()
8

Véase también
Muchas opciones de ploteo están disponibles en Matplotlib. Consulta la
documentación Matplotlib para obtener más detalles. Algunos, los veremos en el
camino.

Advertencia
La imagen a color cargada por OpenCV está en modo BGR. Pero Matplotlib se
muestra en modo RGB. Por lo tanto, las imágenes a color no se mostrarán
correctamente en Matplotlib si se lee la imagen con OpenCV. Por favor revisa los
ejercicios para más detalles.

Empezando con vídeos

Metas
 Aprender a leer vídeo, mostrar vídeo y guardar vídeo.
 Aprender a capturar video desde la cámara y mostrarlo.
 Aprenderás el funcionamiento de las siguientes
funciones: cv2.VideoCapture (), cv2.VideoWriter ()
Vídeos con OpenCV
Captura de vídeo desde la cámara
A menudo, tenemos que capturar transmisiones en vivo con la cámara. OpenCV
proporciona una interfaz muy simple para esto. Vamos a capturar un vídeo desde la cámara
(estoy utilizando una webcam incorporada de mi pc), convirtiendo en vídeo a escala de
grises y mostrándolo. Es una tarea sencilla para empezar.

Para capturar un vídeo, es necesario crear un objeto VideoCapture. Su argumento puede

ser el índice del dispositivo o el nombre de un archivo de vídeo. El índice del dispositivo es
el número para especificar qué cámara se utilizará. Normalmente se conectará una cámara
(como en mi caso). Así que simplemente paso 0 (o -1). Puedes seleccionar una segunda
cámara pasando 1 y así sucesivamente. Después de esto, puedes capturar el vídeo. Pero al
final, no te olvide de liberar la captura.

1
2 import numpy as np
3 import cv2
4 cap = cv2.VideoCapture(0)
5
while(True):
6
# Captura video cuadro a cuadro
7 ret, frame = cap.read()
8 # Nuestras operaciones sobre los cuadros se hacen aqui
9 gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
10 # Muestra el cuadro resultante
cv2.imshow('frame',gray)
11 if cv2.waitKey(1) & 0xFF == ord('q'):
12 break
13
14 # Cuando todo está listo, se libera la captura
15 cap.release()
16 cv2.destroyAllWindows()
17

cap.read() devuelve un bool (verdadero / falso). Si el cuadro se lee correctamente, será

verdadero (true). Por lo tanto, puedes comprobar el final del vídeo consultando este valor
de retorno.
A veces, cap puede no haber inicializado la captura. En ese caso, este código mostrara
error. Puede comprobar si se inicia o no con el método cap.isOpened(). Si es Verdad
(true), excelente. De lo contrario ábrelo con cap.open().
También puede acceder a algunas de las características de este vídeo usando el
método cap.get(PropID), donde PropID es un número del 0 al 18. Cada número indica una
propiedad del video (si es aplicable a ese vídeo) y se puede detallar completamente
aquí: Property Identifier . Algunos de estos valores se pueden modificar mediante cap.set
(propId, value). Valor es el nuevo valor que se desea.
Por ejemplo, puedo comprobar la anchura del marco y la altura
por cap.get(3) and cap.get(4). Da como resultado por defecto 640×480. Pero si quieres
modificarlo a 320×240.Sólo tienes que utilizar ret = cap.set(3,320) y ret = cap.set(4,240)

Nota
Si obtienes un error, asegúrate de que la cámara esta funcionando correctamente
con cualquier otra aplicación.

Reproducción de vídeo desde un archivo

Es lo mismo que capturar desde la Cámara, solo cambie el índice de la cámara con el
nombre del archivo de vídeo. También, mientras que se visualice el cuadro, utiliza el
tiempo apropiado para cv2.waitKey(). Si es demasiado corto, el video será muy rápido y si
es demasiado alto, el video será lento (bueno, esta es una forma de mostrar vídeos en
cámara lenta). 25 milisegundos estarán bien en casos normales.

1
2 import numpy as np
import cv2
3
cap = cv2.VideoCapture('vtest.avi')
4 while(cap.isOpened()):
5 ret, frame = cap.read()
6 gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
7 cv2.imshow('frame',gray)
if cv2.waitKey(1) & 0xFF == ord('q'):
8 break
9 cap.release()
10 cv2.destroyAllWindows()
11

Nota
Asegúrate de que las versiones adecuadas de ffmpeg o gstreamer estén
instaladas. A veces, es un dolor de cabeza para trabajar con Capturas de Video,
principalmente debido a una instalación incorrecta de ffmpeg / gstreamer.

Guardando un video
Supongamos que queremos guardar un vídeo que hemos previamente capturado y
procesado cuadro por cuadro. Para el caso de las imágenes, esto es muy simple, sólo
necesitamos usar cv2.imwrite(). En el caso de los vídeos, sin embargo, se requeire un poco
más de trabajo.
Para esto crearemos un objeto VideoWriter. Primero, debemos especificar el nombre que
queremos dar al fichero (ej: output.avi). Luego tenemos que especificar el
código FourCC (ver detalles más abajo), el número de cuadros por segundo (fps) y el
tamaño de cuadro. El último argumento que debemos pasarle es la bandera isColor. Si es
verdadero, el codificador espera cuadros a color, de lo contrario trabaja con escala de
grises.
FourCC es un código de 4-bytes usado para especificar el códec del vídeo. Una lista de los
diferentes códigos disponibles se puede encontrar en fourcc.org. Estos códigos son
dependientes de la plataforma que estés utilizando, con lo cual, en dependencia del sistema
operativo que estés usando puede que algunos te funcionen y otros no. En el ejemplo que
mostramos más abajo, que ha sido corrido sobre Windows 10, hemos utilizado DIVX.
El código FourCC se puede pasar como cv2.VideoWriter_fourcc(‘M’, ‘J’, ‘P’, ‘G’) o
cv2.VideoWriter_fourcc(*’MJPG) para el códec MJPG.
A continuación se muestra un código que captura vídeo de una cámara, invierte cada
cuadro en la dirección vertical y lo guarda.

import numpy as np
1 import cv2
2
3 cap = cv2.VideoCapture(0)
4
5 # Define el codec y crea el objeto VideoWriter
6 fourcc = cv2.VideoWriter_fourcc(*'DIVX')
out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))
7
8 while(cap.isOpened()):
9 ret, frame = cap.read()
10 if ret==True:
11 frame = cv2.flip(frame,0) #invierte el cuadro
12
# escribe el cuadro invertido
13 out.write(frame)
14 cv2.imshow('frame',frame)
15 if cv2.waitKey(1) & 0xFF == ord('q'):
16 break
17 else:
break
18
19 #Libera todo si la tarea ha terminado
20 cap.release()
21 out.release()
22 cv2.destroyAllWindows()
23
24
25
26