Binarizaión inversa de una imagen - Python

En este ejercicio trataremos de realizar una binarización inversa a la siguiente imagen:

Tal y como se expuso en el anterior post, lo primero que se debe hacer para binarizar una imagen es convertirla a escalas de grises. Para ello, leeremos la imagen en escala de grises, haciéndolo de la siguiente forma:

img = cv2.imread('coca_color.png',0)

También lo podríamos hacer como hemos hecho en el post de conversión a escala de grises.

Posteriormente estableceremos un umbral de 160 y obtendremos la imagen binarizada no invertida (lo haremos para compararla con el resultado final). 

umbral = 160

_ , imgBin = cv2.threshold(img, umbral, 255, cv2.THRESH_BINARY)

Para generar la imagen binarizada invertida lo haremos de una forma muy similar a la anterior, a diferencia del ultimo parametro pasado al método threshold(). Este último será cv2.THRESH_BINARY_INV.

_ , imgBinInv = cv2.threshold(img, umbral, 255, cv2.THRESH_BINARY_INV)

Finalmente visualizamos todas las imagenes para ver el resultado.

cv2.imshow('original', img)
cv2.imshow('binaria', imgBin)
cv2.imshow('binaria_inv', imgBinInv)
cv2.waitKey(0)
cv2.destroyAllWindows()

Código completo:

import cv2

img = cv2.imread('coca_color.png',0)
umbral = 160

_ , imgBin = cv2.threshold(img, umbral, 255, cv2.THRESH_BINARY)
_ , imgBinInv = cv2.threshold(img, umbral, 255, cv2.THRESH_BINARY_INV)

cv2.imshow('original', img)
cv2.imshow('binaria', imgBin)
cv2.imshow('binaria_inv', imgBinInv)
cv2.waitKey(0)
cv2.destroyAllWindows()

Resultado obtenido:

Binarización de una imagen - Python

En este ejercicio el usuario establecerá un umbral, comprendido entre 0 y 255, el cual determinará que pixeles se ponen a negro y cuales a blanco. De esta forma, el color de los pixeles que se hallen por encima de este umbral, serán convertidos a blanco.

Lo primero que debemos hacer es leer una imagen, es importante que esté en escala de grises, si no lo estuviera en post anteriores se muestra como realizar esta transformación. Posteriormente se solicitará al usuario el umbral deseado.

img = cv2.imread('lataCoca.png')
umbral = int(input('intro umbral: '))

Se procede a binarizar la imagen con el método threshold(imagen, umbral, máximo valor de pixeles, tipo binarización) en el cual está albergado en la biblioteca cv2. En nuestro ejercicio, el umbral será un valor elegido por el usuario como ya hemos visto antes y la binarización que utilizaremos será cv2.THRESH_BINARY. El motivo por el que ponemos un guión bajo al principio de la igualdad es porque el método threshold() devuelve dos valores, y a nosotros el único que nos interesa es el segundo.

_ , imgBin = cv2.threshold(img, umbral ,255, cv2.THRESH_BINARY)

Finalmente mostraremos por pantalla la imagen.

cv2.imshow('binaria', imgBin)
cv2.waitKey(0)                   
cv2.destroyWindow('binaria') 

Código completo:

import cv2

img = cv2.imread('lataCoca.png')
umbral = int(input('intro umbral: '))     

_ , imgBin = cv2.threshold(img, umbral ,255, cv2.THRESH_BINARY)

cv2.imshow('binaria', imgBin)
cv2.waitKey(0)                   
cv2.destroyWindow('binaria')     

Resultado obtenido:

La imagen con la que trabajaremos es la siguiente:

Si establecemos un umbral de 127 y los pixeles por encima de este a 255 se obtiene:

En cambio, si mantenemos el mismo umbral, 127, pero los pixeles por encima de este los forzamos a que tengan un valor de 158 se obtendrá el resultado que se muestra a continuación. Vemos como el blanco ha pasado a ser un gris.

_ , imgBin = cv2.threshold(img, umbral ,158, cv2.THRESH_BINARY)

Representar imágenes con filtro de color - Python

En primer lugar se deberán importar las bibliotecas cv2 y matplotlib.pyplot. Posteriormente se lee la imagen con la que trabajaremos y utilizaremos el método split() para dividirla en tres canales: B, G, R (openCV los toma en ese orden, tal y como hemos explicado en post anteriores). 

import cv2
import matplotlib.pyplot as plt

img_color = cv2.imread('parchis.jpg')

B, G, R=cv2.split(img_color)

Una vez que tenemos los canales separados, formaremos unas imágenes que darán la sensación de que hay un filtro de color. En el caso del filtro azul, utilizaremos el método merge() para mezclar los canales, pero dicha imagen solo tendrá componente del canal azul, haciendo así las otras componentes cero. Análogamente generaremos el filtro verde y rojo.

azul = cv2.merge([R*0, G*0, B])
verde = cv2.merge([R*0, G, B*0])
rojo = cv2.merge([R, G*0, B*0])

Finalmente, visualizamos la imagen RGB y las otras tres generadas en el plot.

plt.subplot(1,4,1), plt.imshow(cv2.merge([R,G,B]))
plt.title('RGB')
plt.axis(False)

plt.subplot(1,4,2), plt.imshow(azul)
plt.title('Azul')
plt.axis(False)

plt.subplot(1,4,3), plt.imshow(verde)
plt.title('Verde')
plt.axis(False)

plt.subplot(1,4,4), plt.imshow(rojo)
plt.title('Rojo')
plt.axis(False)

Código completo:

import cv2
import matplotlib.pyplot as plt

img_color = cv2.imread('parchis.jpg')

#Dividimos los 3 canales
B, G, R=cv2.split(img_color)

azul = cv2.merge([R*0, G*0, B])
verde = cv2.merge([R*0, G, B*0])
rojo = cv2.merge([R, G*0, B*0])

plt.subplot(1,4,1), plt.imshow(cv2.merge([R,G,B]))
plt.title('RGB')
plt.axis(False)

plt.subplot(1,4,2), plt.imshow(azul)
plt.title('Azul')
plt.axis(False)

plt.subplot(1,4,3), plt.imshow(verde)
plt.title('Verde')
plt.axis(False)

plt.subplot(1,4,4), plt.imshow(rojo)
plt.title('Rojo')
plt.axis(False)

Resultado obtenido:

Acceso a canales de imagen con índices (matrices) - Python

Con el código que realizaremos obtendremos el mismo resultado que en el post anterior, con la diferencia de que en este caso no utilizaremos el método split() para obtener los tres canales de la imagen. Para ello, trabajaremos con matrices de tal forma que cada canal será el correspondiente a un índice.

Es importante recordar que internamente openCV no trabaja con RGB si no con BGR, por lo tanto el primer canal será el azul, el segundo el verde y el tercero el rojo. Para seleccionar estos, asignaremos a la variable B (blue) aquella matriz de la imagen correspondientes a todas las filas (:), todas las columnas (:) y el primer canal (0). Análogamente declararemos las variables G (green) y R (red).

M = cv2.imread('parchis.jpg')

B = M[:,:,0]
G = M[:,:,1]
R = M[:,:,2]

Posteriormente las mostraremos en el plot en 1 fila y 5 columnas. En mi caso en primer lugar he representado la imagen de la que partimos RGB, fusionando los tres canales con el método merge(). Al tener los tres canales separador, podremos generar una imagen con el orden de canales que queramos, en mi caso he representado también la imagen con el orden BGR.

Código completo:

import cv2
import matplotlib.pyplot as plt

M = cv2.imread('parchis.jpg')

#Acceso a canales con indices
B = M[:,:,0]
G = M[:,:,1]
R = M[:,:,2]


plt.subplot(1,5,1), plt.imshow(cv2.merge([R,G,B]))
plt.title('RGB')
plt.axis(False)

plt.subplot(1,5,2), plt.imshow(R, 'gray')
plt.title('Red')
plt.axis(False)

plt.subplot(1,5,3), plt.imshow(G, 'gray')
plt.title('Green')
plt.axis(False)

plt.subplot(1,5,4), plt.imshow(B, 'gray')
plt.title('Blue')
plt.axis(False)

plt.subplot(1,5,5), plt.imshow(cv2.merge([B,G,R]))
plt.title('BGR')
plt.axis(False)

Resultado obtenido:

Representar imágenes con matplotlib - Python

Lo primero que debemos hacer es incluir dos bibliotecas: cv2 y matplotlib.pyplot. Para simplificar el código a la hora de utilizar la segunda, le asignaremos el nombre plt.

import cv2
import matplotlib.pyplot as plt

Al igual que hicimos en el post anterior, leemos la imagen y  utilizaremos split() para separar los tres canales: B, G y R. Es importante realizar la transformación de RGB (formato que utilizamos habitualmente) a BGR (el que utiliza openCV). Lo haremos de la siguiente forma:

B, G, R = cv2.split(img_color)

img_RGB=cv2.cvtColor(img_color,cv2.COLOR_RGB2BGR)

Finalmente mostramos las imágenes que queramos en el plot, en mi caso mostraré la imagen RGB y los tres canales. Las visualizaré en dos filas y dos columnas, formando así un cuadrado. Esto lo conseguiremos con el método subplot(filas, columnas, posición del elemento). Después indicaremos el nombre de la imagen que queremos representar, junto con su título.

plt.subplot(2,2,1), plt.imshow(img_RGB)
plt.title('Color')

En mi caso no quiero mostrar la escala de las imágenes 'img_RGB', 'B' y 'G', por ello, pondré a False el método axis().  En la imagen 'R' sí que mostraré la escala.

plt.axis(False)

Código completo:

import cv2
import matplotlib.pyplot as plt

img_color = cv2.imread('Bandera.png') 

B, G, R = cv2.split(img_color) 

#De RGB a BGR
img_RGB=cv2.cvtColor(img_color,cv2.COLOR_RGB2BGR)

plt.subplot(2,2,1), plt.imshow(img_RGB)
plt.title('Color')
plt.axis(False)

plt.subplot(2,2,2), plt.imshow(B, 'gray')
plt.title('Blue')
plt.axis(False)

plt.subplot(2,2,3), plt.imshow(G, 'gray')
plt.title('Green')
plt.axis(False)

plt.subplot(2,2,4), plt.imshow(R, 'gray')
plt.title('Red')

Representación en el plot:

Separar canales BGR con split - Python

En primer lugar, importamos la biblioteca cv2 y cargamos una imagen a color, en mi caso se trata de la bandera de Namibia. 

import cv2
img_color = cv2.imread('Bandera.png')

Posteriormente utilizamos el método split() para separar la imagen en tres canales: azul (B), verde (G) y rojo (R). Normalmente los canales se toman en el orden RGB pero es importante tener en cuenta que openCV los invierte resultando BGR, por lo tanto tomaremos este último orden.

B, G, R = cv2.split(img_color) 

Mostramos las imágenes generadas por pantalla como ventanas emergentes:

cv2.imshow('Color',img_color)
cv2.imshow('Azul',B)
cv2.imshow('Verde',G)
cv2.imshow('Rojo',R)

cv2.waitKey(0)
cv2.destroyAllWindows()

Vemos como se aclara las zonas en las cuales el color coincide con el canal, es decir, si tomamos el canal azul, se aclaran aquellas zonas que en la imagen original son azules. Además se puede apreciar como el color amarillo correspondiente al sol de la bandera es una mezcla de verde y rojo (más rojo que verde). Esto se puede deducir ya que en las imágenes correspondientes a estos canales el sol sale con un tono muy claro (cuanto más claro, más componente del color del canal tratado).

Finalmente guardamos las imágenes:

cv2.imwrite('imgAzul.png',B)
cv2.imwrite('imgVerde.png',G)
cv2.imwrite('imgRojo.png',R)

Programa completo:

import cv2

img_color = cv2.imread('Bandera.png')

#Generar imagenes B, G, R
B, G, R = cv2.split(img_color) 

cv2.imshow('Color',img_color)
cv2.imshow('Azul',B)
cv2.imshow('Verde',G)
cv2.imshow('Rojo',R)

cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.imwrite('imgAzul.png',B)
cv2.imwrite('imgVerde.png',G)
cv2.imwrite('imgRojo.png',R)

Resultado final:

Convertir imagen a escala de grises - Python

En primer lugar se debe importar la biblioteca 'cv2' que nos permitirá resolver problemas de visión artificial en imágenes. Lo haremos con la siguiente línea de código:

import cv2

Es importante que en el ubicación donde está guardado el .py con el que estamos trabajando, se aloje también la imagen con la que trabajaremos. En mi caso trabajaré con un tablero de parchís.

Una vez que tenemos preparada la imagen en el directorio, procedemos a leerla y a guardarla en una variable llamada img_color. Para ello, utilizaremos la biblioteca cv2 la cual consta de un método imread(). En los paréntesis pondremos el nombre de la imagen que vamos a tratar entre comillas:

img_color = cv2.imread('parchis.png')

Ahora se procede a hacer la transformación a escala de grises. Utilizaremos primeramente el método cvtColor() de la biblioteca cv2 pasando como parámetros la imagen que queremos convertir, en mi caso img_color, y seguidamente COLOR_BGR2GRAY. Esta transformación la guardaremos en la variable img_gray.

img_gray = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)

Mostraremos el resultado obtenido por pantalla con imshow() y destruiremos las ventanas generadas con waitKey() y destroyAllWindows().

cv2.imshow('Color', img_color)
cv2.imshow('Gris', img_gray)

cv2.waitKey(0)
cv2.destroyAllWindows()

Finalmente guardaremos la imagen de escala de grises con el nombre que queramos indicándolo entre comillas. Para ello, haremos uso del método imwrite() de la siguiente forma:

cv2.imwrite('Mi_img_gris.png', img_gray)

Código completo:

import cv2

#cargar imagen a color de parchis
img_color = cv2.imread('parchis.png')   

#Transformacion a gris 
img_gray = cv2.cvtColor(img_color, cv2.COLOR_BGR2GRAY)

#Mostrar imagenes por pantalla
cv2.imshow('Color', img_color)
cv2.imshow('Gris', img_gray)

#Cerrar ventanas
cv2.waitKey(0)
cv2.destroyAllWindows()

#Guardar imagen gris generada
cv2.imwrite('Mi_img_gris.png', img_gray)

Resultado obtenido: