RGB en OpenCV – Python

May 2, 2023

1 RGB en OpenCV – Python

2 CONTENIDO:
2.0.1 - RGB en OpenCV
2.0.2 - Construyendo una imagen con numpy
2.0.3 - Imagen de BGR a RGB
2.1 1. RGB en OpenCV
Una imagen es un conjunto de pixeles distribuidos en forma de cuadrícula. Cada pixel a su vez
está conformado por otros componentes, que combinados forman los colores que podemos ver en
una imagen. Hoy hablaremos de aquellos componentes que estructuran un color, principalmente
RGB, y como se utiliza en OpenCV.
RGB (Red Green Blue / Rojo Verde Azul), es uno de los espacios de color más utilizado en cuanto
a imágenes se trata y el que usa por defecto OpenCV al momento de leer una imagen o dibujar
figuras geométricas, por ello es de vital importancia conocer como se maneja este espacio de color
en esta librería, es más el tener esta información a la mano te quitará algunos dolores de cabeza si
estás empezando a realizar aplicaciones de visión por computador.
Atención: El orden en el que OpenCV usa estos componentes es en BGR, no RGB. Sí, a pesar de
no parecer muy importante, en realidad te puede ayudar a entender desde ya como asignar distintos
colores en este formato. La siguiente es una lista de colores y como están compuestos:

[92]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("coloresBGR-768x768.png")
plt.figure(figsize=(16,16))
plt.imshow(imagen)

plt.text(330,800,"Figura 1", fontsize = 20,

bbox = dict(facecolor = 'red', alpha = 0.5))

plt.axis("off")

[92]: (-0.5, 767.5, 767.5, -0.5)

1
Hay que tomar en cuenta que RGB, posee 3 componentes y cada uno toma valores de entre 0 y
255. Analizando la figura 1 por ejemplo, para representar el color negro, cada uno de los canales
tiene valor de 0, mientras que para representar el color blanco todos poseen 255.
Si se quiere representar los colores básicos en rgb, es decir, rojo verde y azul, basta con elevar a
255 el canal al que corresponde y el resto 0, como se puede ver en la figura 1. Por otro lado para
obtener otros colores se necesita distintos valores en los canales, como podemos ver en la segunda
columna de la imagen, donde se ha representado por ejemplo el color aqua, fucsia, amarillo, marrón
y naranja.
Teniendo en claro como se estructuran los colores en rgb y cómo los usa OpenCV podemos continuar
construyendo una imagen con la librería Numpy.

2
 2.2 2. Construyendo una imagen con numpy
Numpy es una librería matemática que trabaja conjuntamente con OpenCV para realizar múltiples
procesos, pues trata a la imagen como una matriz de diversos canales. Por esta razón nos ayudare-
mos de esta librería para construir una imagen de distintos colores, a continuación la programación:

[61]: import cv2

import numpy as np
bgr = np.zeros((300, 300, 3), dtype=np.uint8)
cv2.imshow('BGR', bgr)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.imwrite("Fondo.png",bgr) #

[61]: True

Analicemos las líneas de este programa:

Línea 1 y 2: Importar las librerías necesarias OpenCV y numpy con el alias np.
Línea 4: Aquí es donde se está construyendo la imagen, con np.zeros, es decir estamos creando
una matriz de ceros, de 300 filas, 300 columnas de 3 canales, correspondientes a BGR. Se especifica
el tipo de dato con np.uint8, esto quiere decir que se tomará valores de entre 0 y 255.
Línea 5 a 7: Se realiza la visualización de la imagen, lo que mostraría:

[62]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("Fondo.png")
plt.figure(figsize=(4,4))
plt.imshow(imagen)

plt.text(80,350,"Figura 2", fontsize = 20,

bbox = dict(facecolor = 'red', alpha = 0.5))
#plt.text(80,350,"Imagen 1", fontsize = 20,color = 'red')

plt.axis("off")

[62]: (-0.5, 299.5, 299.5, -0.5)

3
 Se puede modificar el color de la imagen creada añadiendo una línea en donde especifique las filas,
columnas en donde se debe representar el nuevo color.

[63]: import cv2

import numpy as np
bgr = np.zeros((300, 300, 3), dtype=np.uint8)
bgr[:,:,:] = (255, 0, 100)
cv2.imshow('BGR', bgr)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite("Fondo.png",bgr) #

[63]: True

Línea 5: Se toma todos los elementos de la matriz creada y se asignan nuevos valores para
representar un nuevo color, en BGR.
Se visualizaría de la siguiente manera:

[64]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("Fondo.png")
plt.figure(figsize=(4,4))
plt.imshow(imagen)

4
 plt.text(80,350,"Figura 3", fontsize = 20,
bbox = dict(facecolor = 'red', alpha = 0.5))
plt.axis("off")

[64]: (-0.5, 299.5, 299.5, -0.5)

¡A practicar, modificando una imagen creada con numpy!

Si quieres practicar un poco más con la representación de distintos colores sobre una imagen creada
con numpy te dejo el siguiente programa que puedes analizar:

[65]: import cv2

import numpy as np
bgr = np.zeros((500,800,3),dtype=np.uint8)
font = cv2.FONT_HERSHEY_SIMPLEX
#AZUL-------------------------------------------------------------
bgr[:100, :200] = (255,0,0)
bgr[:100, 200:400] = (255)
bgr[:100, 400:600] = (0)
bgr[:100, 600:800] = (0)
cv2.putText(bgr,'Azul (255,0,0) -->',(5,55), font, 0.5,(255,255,255),1,cv2.
↪LINE_AA)

cv2.putText(bgr,'B= 255',(220,55), font, 1,(255,0,0),2,cv2.LINE_AA)

cv2.putText(bgr,'G= 0',(440,55), font, 1,(255,0,0),2,cv2.LINE_AA)
cv2.putText(bgr,'R= 0',(640,55), font, 1,(255,0,0),2,cv2.LINE_AA)

5
 #VERDE------------------------------------------------------------
bgr[100:200, :200] = (0,255,0)
bgr[100:200, 200:400] = (0)
bgr[100:200, 400:600] = (255)
bgr[100:200, 600:800] = (0)
cv2.putText(bgr,'Verde (0,255,0) -->',(5,145), font, 0.5,(255,255,255),1,cv2.
↪LINE_AA)

cv2.putText(bgr,'B= 0',(240,155), font, 1,(0,255,0),2,cv2.LINE_AA)

cv2.putText(bgr,'G= 255',(420,155), font, 1,(0,255,0),2,cv2.LINE_AA)
cv2.putText(bgr,'R= 0',(640,155), font, 1,(0,255,0),2,cv2.LINE_AA)
#ROJO------------------------------------------------------------
bgr[200:300, :200] = (0,0,255)
bgr[200:300, 200:400] = (0)
bgr[200:300, 400:600] = (0)
bgr[200:300, 600:800] = (255)
cv2.putText(bgr,'Rojo (0,0,255) -->',(5,245), font, 0.5,(255,255,255),1,cv2.
↪LINE_AA)

cv2.putText(bgr,'B= 0',(240,255), font, 1,(0,0,255),2,cv2.LINE_AA)

cv2.putText(bgr,'G= 0',(440,255), font, 1,(0,0,255),2,cv2.LINE_AA)
cv2.putText(bgr,'R= 255',(620,255), font, 1,(0,0,255),2,cv2.LINE_AA)
#Naranja
bgr[300:400, :200] = (20,117,240)
bgr[300:400, 200:400] = (20)
bgr[300:400, 400:600] = (117)
bgr[300:400, 600:800] = (240)
cv2.putText(bgr,'Naranja(20,117,240)->',(5,345), font, 0.5,(255,255,255),1,cv2.
↪LINE_AA)

cv2.putText(bgr,'B= 20',(230,355), font, 1,(20,117,240),2,cv2.LINE_AA)

cv2.putText(bgr,'G= 117',(420,355), font, 1,(20,117,240),2,cv2.LINE_AA)
cv2.putText(bgr,'R= 240',(620,355), font, 1,(20,117,240),2,cv2.LINE_AA)
bgr[400:500, :200] = (109,45,215)
bgr[400:500, 200:400] = (109)
bgr[400:500, 400:600] = (45)
bgr[400:500, 600:800] = (215)
cv2.putText(bgr,'Rosa (109,45,215)-->',(5,445), font, 0.5,(255,255,255),1,cv2.
↪LINE_AA)

cv2.putText(bgr,'B= 109',(220,455), font, 1,(109,45,215),2,cv2.LINE_AA)

cv2.putText(bgr,'G= 45',(430,455), font, 1,(109,45,215),2,cv2.LINE_AA)
cv2.putText(bgr,'R= 215',(620,455), font, 1,(109,45,215),2,cv2.LINE_AA)
cv2.imshow('B= Blue, G= Green, R= Red',bgr)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.imwrite("ImagenColores.png",bgr) #

[65]: True

6
 Nota: Si se iguala cierta cantidad de pixeles a un solo valor, como gran parte del código (líneas 8
a 10, 19 a 21, 30 a 32, 41 a 43, 51 a 53), se asigna dicho valor a los 3 canales de B, G y R.
Teniendo como resultado la siguiente imagen:

[66]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("ImagenColores.png")
plt.figure(figsize=(8,8))
plt.imshow(imagen)
plt.text(300,540,"Figura 4", fontsize = 20,
bbox = dict(facecolor = 'red', alpha = 0.5))
plt.axis("off")

[66]: (-0.5, 799.5, 499.5, -0.5)

La primera columna de la figura 4, muestra distintos colores, mientras que a su derecha se muestran
los valores de cada componente en BGR, para obtener dichos colores. Por ejemplo, para poder
obtener el color azul, se necesita que B esté en 255, mientras que G y R en 0.

7
 2.3 3. Imagen de BGR a RGB
Pueden haber casos en los que necesites cambiar el orden de los canales de bgr a rgb. Para este
ejemplo se usará la siguiente imagen:

[94]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("prueba.png")
plt.figure(figsize=(8,8))
plt.imshow(imagen)

plt.text(175,350,"Figura 5", fontsize = 20,

bbox = dict(facecolor = 'red', alpha = 0.5))

plt.axis("off")

[94]: (-0.5, 399.5, 330.5, -0.5)

8
 Para transformar de bgr a rgb necesitamos de la función cv2.cvtColor, a la cual debemos entregar
la imagen a la que queremos procesar, seguido de cv2.COLOR_BGR2RGB.

[4]: import cv2

import numpy as np

bgr = cv2.imread('prueba.png')
C1 = bgr[:,:,0]
C2 = bgr[:,:,1]
C3 = bgr[:,:,2]
cv2.imshow('BGR',np.hstack([C1,C2,C3]))
cv2.imwrite("Loro_01_1x3.png",np.hstack([C1,C2,C3])) #
rgb = cv2.cvtColor(bgr,cv2.COLOR_BGR2RGB)
C1 = rgb[:,:,0]
C2 = rgb[:,:,1]
C3 = rgb[:,:,2]
cv2.imshow('RGB',np.hstack([C1,C2,C3]))
cv2.imwrite("Loro_02_1x3.png",np.hstack([C1,C2,C3])) #
cv2.waitKey(0)
cv2.destroyAllWindows()

Línea 4: Se lee la imagen, como no se ha especificado una forma de lectura, por defecto está
leyendo la imagen en bgr.
Línea 5 a 7: Se separa cada uno de los canales correspondientes a b: bgr[:,:,0], g: bgr[:,:,1] y r:
bgr[:,:,2]. Para posteriormente visualizar el cambio de orden.
Línea 8: Se visualiza cada uno de los canales uno al lado del otro usando la función np.hstack.
Línea 10: Se transforma de bgr a rgb.
Línea 11 a 14: Se realiza un proceso similar al de las líneas 5 a 8, para la imagen en rgb.
Ahora vamos a visualizar las dos imágenes obtenidas:

[76]: import matplotlib.pyplot as plt

import matplotlib.image as mpi

imagen=mpi.imread("Loro_01_1x3.png")
plt.figure(figsize=(8,8))
plt.imshow(cv2.cvtColor(imagen,cv2.COLOR_BGR2RGB))
plt.text(450,390,"Figura 6", fontsize = 20,
bbox = dict(facecolor = 'red', alpha = 0.5))
plt.axis("off")

imagen2=mpi.imread("Loro_02_1x3.png")
plt.figure(figsize=(8,8))
plt.imshow(cv2.cvtColor(imagen2,cv2.COLOR_BGR2RGB))
plt.text(450,400,"Figura 7", fontsize = 20,

9
 bbox = dict(facecolor = 'red', alpha = 0.5))
plt.axis("off")

[76]: (-0.5, 1199.5, 330.5, -0.5)

Tomando como base la figura 5, si la descomponemos en sus 3 canales se obtienen resultados como se
visualiza en la figura 6, allí podemos ver el orden de los canales BGR. Mientras que si aplicáramos
la función cv2.cvtColor, y luego especificamos cv2.COLOR_BGR2RGB, se está cambiando
el orden de estos canales y se obtendría una imagen en RGB.
En ambas figuras (6 y 7), podemos ver cada componente en escala de grises, esto es debido a
que por separado se visualiza de esa manera, mientras que cuando se integran los 3 componentes se
visualiza una imagen a color. Aquí lo que se quería lograr, es visualizar como se cambian de orden
los canales al aplicar cv2.cvtColor.

10