Detección de colores con OpenCV y Python

Buenos días, homo fabers. Hoy voy a enseñaros cómo identificar objetos de color con OpenCV y Python. Uno de los “problemas” que tiene esta librería a la hora de trabajar con detección de colores es que hay infinitud de formas de hacerlo: por contornos, por momentos, calculando áreas, etc. Además, no nos basta con aplicar las funciones de detección de color, ya que se genera una gran cantidad de ruido del que habrá que encargarse para conseguir un resultado fiable.

Si has buscado información en internet o en la documentación oficial probablemente tengas dolor de cabeza. Así que este tutorial propone un sistema que si bien no es el único y tampoco el más efectivo, tiene algunos aspectos muy positivos: funciona, detecta vídeo, elimina el ruido y te da las coordenadas del objeto. Con una velocidad aceptable.

Al analizar la imagen, se produce gran cantidad de ruido que deberemos eliminar

Voy a explicar cada uno de los pasos que he seguido para escribir el código. Aunque si dedicar 15 minutos de tu vida te parece demasiado, al final aparece el código completo para que puedas copiarlo y pegarlo directamente y así no tener que usar tu cerebro de humano para intentar comprender el apasionante mundo del reconocimiento visual.

Dicho esto, es hora de poner un poco de música y empezar a trabajar.

El concepto

Para reconocer y marcar un objeto de un color determinado seguiremos estos pasos:

1. Capturar una imagen con la cámara.
2. Convertir la imagen de RGB a HSV.
3. Buscar objetos del color deseado.
4. Eliminar ruido
5. Mostrar la imagen

 1. Capturar Imagen

Cargamos las librerías cv2 y numpy. Activamos la cámara y guardamos lo que lee.

import cv2
import numpy as np

captura = cv2.VideoCapture(0)

 2. Convertir la imagen

Creamos un bucle infinito (while(1) o while(true)). Dentro, leemos un frame y lo guardamos dentro de una variable que llamaremos ‘imagen’, después convertimos este frame a HSV, ya que es más fácil analizar imágenes en este modelo de color.

while(1):
   _, imagen = captura.read()

   hsv = cv2.cvtColor(imagen, cv2.COLOR_BGR2HSV)

 3. Buscar objetos verdes

Necesitamos dos arrays para guardar el rango de colores que detectamos. El límite inferior será 49, 50, 50, un verde oscuro. El límite superior será 80, 255, 255, un verde marino muy claro. Nuestro programa detectará todos los colores dentro de este rango.

   verde_bajos = np.array([49,50,50])
   verde_altos = np.array([80, 255, 255])

¿Y por qué objetos verdes? Porque me gusta el color verde. ¿A vosotros no?

Necesitamos saber qué pixeles de la imagen están dentro del rango. Para ello crearemos una máscara que los guarde.

¿Pero qué es una máscara? Se trata de una imagen que contiene únicamente dos colores: blanco y negro. En nuestro caso pintará de blanco los píxeles verdes y de negro el resto. Por ejemplo, la imagen que he puesto al inicio es una máscara que detecta color verde:

   mask = cv2.inRange(hsv, verde_bajos, verde_altos)

 4. Eliminar ruido

Necesitamos desechar todos aquellos objetos que no lleguen a un tamaño determinado (ruido).

Para empezar calcularemos el momento de los objetos que hemos detectado. El momento se utiliza en matemáticas para encontrar la forma que adoptan un conjunto de puntos.

La función cv2.moments() nos da como output un diccionario. Nos interesa la clave ‘m00’, que guarda el valor del área del momento.

   moments = cv2.moments(mask)
   area = moments['m00']

   #Para visualizar el area descomentamos la siguiente linea
   #print area

A fin de eliminar el ruido, nos quedaremos únicamente con aquéllos objetos cuya área supere un determinado valor. Para ello utilizaremos un condicional. Después de jugar con distintos números encontré que 2000000 es una cifra bastante estándar que a mí me funciona.

Buscamos el centro del objeto en cuestión y mostramos sus coordenadas en pantalla. Para visualizarlo en la imagen dibujaremos un pequeño rectángulo rojo.

   if(area > 2000000):
      #Buscamos los centros
      x = int(moments['m10']/moments['m00'])
      y = int(moments['m01']/moments['m00'])

      #Escribimos el valor de los centros
      print "x = ", x
      print "y = ", y

      #Dibujamos el centro con un rectangulo
      cv2.rectangle(imagen, (x, y), (x+2, y+2),(0,0,255), 2)

5. Mostrar la imagen

Mostraremos dos ventanas. En la primera aparecerá la imagen original con el centro del objeto. La segunda será la máscara en blanco y negro.

   cv2.imshow('mask', mask)
   cv2.imshow('Camara', imagen)

Con escape se cierra el programa:

   #Se sale con ESC
   tecla = cv2.waitKey(5) & 0xFF
   if tecla == 27:
      break

cv2.destroyAllWindows()

El código completo

He aquí el código completo que he escrito. Sóis libres de modificarlo para adaptarlo a vuestras necesidades.

#Algoritmo de deteccion de colores
#Por Glar3
#
#
#Detecta objetos verdes, elimina el ruido y busca su centro

import cv2
import numpy as np

#Iniciamos la camara
captura = cv2.VideoCapture(0)

while(1):
    
    #Capturamos una imagen y la convertimos de RGB -> HSV
    _, imagen = captura.read()
    hsv = cv2.cvtColor(imagen, cv2.COLOR_BGR2HSV)

    #Establecemos el rango de colores que vamos a detectar
    #En este caso de verde oscuro a verde-azulado claro
    verde_bajos = np.array([49,50,50], dtype=np.uint8)
    verde_altos = np.array([80, 255, 255], dtype=np.uint8)

    #Crear una mascara con solo los pixeles dentro del rango de verdes
    mask = cv2.inRange(hsv, verde_bajos, verde_altos)

    #Encontrar el area de los objetos que detecta la camara
    moments = cv2.moments(mask)
    area = moments['m00']

    #Descomentar para ver el area por pantalla
    #print area
    if(area > 2000000):
        
        #Buscamos el centro x, y del objeto
        x = int(moments['m10']/moments['m00'])
        y = int(moments['m01']/moments['m00'])
        
        #Mostramos sus coordenadas por pantalla
        print "x = ", x
        print "y = ", y

        #Dibujamos una marca en el centro del objeto
        cv2.rectangle(imagen, (x, y), (x+2, y+2),(0,0,255), 2)
    
    
    #Mostramos la imagen original con la marca del centro y
    #la mascara
    cv2.imshow('mask', mask)
    cv2.imshow('Camara', imagen)
    tecla = cv2.waitKey(5) & 0xFF
    if tecla == 27:
        break

cv2.destroyAllWindows()

Y esto es todo por hoy. Si habéis seguido cada paso debería de funcionar sin ningún problema.

Podéis dejar vuestras dudas e incidencias en los comentarios y prometo resolverlas en cuanto pueda. Asimismo, si este tutorial os ha servido no dudéis en darme las gracias. Voy a estar agradecida 😉

-Actualización 12/11/2015-

Muchos de vosotros, lectores, me habéis preguntado cómo detectar colores que no sean verde: amarillos, rojos, azules…

Como creo que a muchos os está costando entender cómo funciona el espacio de color HSV y qué significan los arrays de valores máximos y mínimos que usamos en OpenCV para detectar colores, voy a dar una explicación más detallada sobre el tema. Además, voy a añadir un código en Python que me pasó un amigo para poder ajustar estos valores HSV en tiempo real con barras de desplazamiento.

¿Qué es el espacio de color HSV?

Cuándo vemos un color en la pantalla, lo que en realidad estamos viendo son miles de píxeles que brillan con una cierta intensidad. Cada píxel está formado por tres luces: una roja, una verde y una azul. La sensación de color se produce variando la intensidad de estas tres luces y alterando así la cantidad de luz roja, azul y verde que reciben los ojos del usuario.

Dentro del ordenador, los colores vienen codificados por números. Hay varias formas de codificar los colores. La más popular es el sistema de color RGB, que sin duda todos conocéis. Este sistema asigna a cada color una cantidad de Rojo, Verde y Azul entre 0 y 255. Por ejemplo, el rojo puro es [255,0,0]. Hasta aquí todo correcto, ¿no?

Pero hay otras formas de codificar los colores. El HSV (del inglés Hue,Saturation,Value – Tono, Saturación y Valor) es ideal para reconocimiento de colores.

¿Qué significan estos tres valores?

• Hue (H) es el tono de color (por ejemplo verde, rojo, morado…)
• Saturation (S) es la intensidad de esta tonalidad. Cuanta menos saturación, más gris es el color.
• Value (V) es la luminosidad del color.

Ejemplo de color HSV

Nota importante: en algunos programas el rango de Hue es de 0 a 100 o de 0 a 360. También hay veces en que Saturation y Value van de 0 a 100. El rango de OpenCV es de 0 a 255 para H, S y V.

OpenCV: rango de valores máximo y mínimo

Conceptualmente, ¿cómo lo hace OpenCV para detectar colores? El programa busca los píxeles de la imagen que estén entre un valor mínimo y máximo.

Fíjemonos en esta parte del código del tutorial:

    verde_bajos = np.array([49,50,50], dtype=np.uint8)
    verde_altos = np.array([80, 255, 255], dtype=np.uint8)

    #Crear una mascara con solo los pixeles dentro del rango de verdes
    mask = cv2.inRange(hsv, verde_bajos, verde_altos)

Las dos primeras líneas crean un array. El primero son los valores mínimos de H, S y V que buscará el programa, y el segundo son los valores máximos. En la última línea se llama la función para detectar colores. Recibe como parámetros la imagen (‘hsv’) y el array de valores mínimos y máximos.

Fíjemonos en el array verde_bajos y verde_altos:

verde_bajos: [49,50,50]
verde_altos: [80, 255, 255]

Eso siginifica que el programa buscará píxeles que cumplan estas tres condiciones a la vez:

1. Su valor Hue esté entre 49 y 80
2. Su valor Saturation esté entre 50 y 255
3. Su valor Value esté entre 50 y 255

Este color tiene los valores H,S y V dentro del rango, por lo tanto será detectado

En cambio, este púrpura tiene el valor H fuera del rango. No será detectado.

Si queremos cambiar el color a detectar, tenemos que modificar los valores de los arrays. ¿Cómo podemos ver cuál es el rango HSV de nuestro color?

Lo más fácil es abrir un programa de diseño gráfico como Gimp, Inkscape o Photoshop (o Paint, si no tenéis orgullo) y mirar el rango de colores en la paleta. Supongamos que queremos detectar amarillos:

La otra opción es utilizar este código. Se trata de un código de detección de colores que permite ajustar los valores HSV en tiempo real mediante barras de desplazamiento. Hay que ajustarlas hasta que en la máscara aparezcan sólo los colores deseados.

import serial
import cv2
import numpy as np

cap = cv2.VideoCapture(0)

def nothing(x):
   pass

#Creamos una ventana llamada 'image' en la que habra todos los sliders
cv2.namedWindow('image')
cv2.createTrackbar('Hue Minimo','image',0,255,nothing)
cv2.createTrackbar('Hue Maximo','image',0,255,nothing)
cv2.createTrackbar('Saturation Minimo','image',0,255,nothing)
cv2.createTrackbar('Saturation Maximo','image',0,255,nothing)
cv2.createTrackbar('Value Minimo','image',0,255,nothing)
cv2.createTrackbar('Value Maximo','image',0,255,nothing)

while(1):
  _,frame = cap.read() #Leer un frame
  hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) #Convertirlo a espacio de color HSV

  #Los valores maximo y minimo de H,S y V se guardan en funcion de la posicion de los sliders
  hMin = cv2.getTrackbarPos('Hue Minimo','image')
  hMax = cv2.getTrackbarPos('Hue Maximo','image')
  sMin = cv2.getTrackbarPos('Saturation Minimo','image')
  sMax = cv2.getTrackbarPos('Saturation Maximo','image')
  vMin = cv2.getTrackbarPos('Value Minimo','image')
  vMax = cv2.getTrackbarPos('Value Maximo','image')

  #Se crea un array con las posiciones minimas y maximas
  lower=np.array([hMin,sMin,vMin])
  upper=np.array([hMax,sMax,vMax])

  #Deteccion de colores
  mask = cv2.inRange(hsv, lower, upper)

  #Mostrar los resultados y salir
  cv2.imshow('camara',frame)
  cv2.imshow('mask',mask)
  k = cv2.waitKey(5) & 0xFF
  if k == 27:
    break
cv2.destroyAllWindows()

Actualización 3/11/2016: Resolución de errores frecuentes con OpenCV+Python