Procesamiento de imagen python-OpenCv Lectura de imagen capas BGR

Proyectos JC
6 Mar 202117:06

Summary

TLDREste video tutorial en español guía a los usuarios sobre cómo trabajar con la lectura y escritura de imágenes en Python utilizando OpenCV. Se explica cómo se representan las imágenes RGB en tres matrices bidimensionales y cómo se pueden manipular estas capas individualmente. Se muestran comandos básicos para leer, mostrar y guardar imágenes, así como para transformar espacios de color de BGR a RGB. Además, se demuestra cómo extraer y visualizar cada capa de color, y se da un ejemplo de cómo mostrar imágenes con un color solo para ilustrar la teoría.

Takeaways

  • 😀 Una imagen en formato RGB se representa mediante tres matrices bidimensionales, correspondientes a los planos de color azul, verde y rojo.
  • 🔍 En Python, utilizando OpenCV, las imágenes se leen y se representan en formato BGR, no RGB, y se indexan desde 0 a 2.
  • 📚 Al leer una imagen, se obtienen matrices bidimensionales que representan los valores de cada capa y, por tanto, los colores según la intensidad de cada píxel.
  • 🖼️ Para leer una imagen en OpenCV, se utiliza la función `cv2.imread()`, y para mostrarla, se emplea `cv2.imshow()`.
  • ⏱️ La función `cv2.waitKey()` permite hacer que la ventana de la imagen se mantenga abierta hasta que se presione una tecla, y `cv2.destroyAllWindows()` cierra todas las ventanas abiertas.
  • 🔄 Se pueden transformar imágenes de color a escala de grises y viceversa mediante el uso de argumentos en las funciones de lectura y escritura.
  • 📁 Es recomendable trabajar con la imagen y el archivo de código en la misma carpeta o utilizar rutas absolutas para la lectura de archivos.
  • 🔀 Para concatenar matrices y mostrarlas como una sola imagen, se utiliza la función `np.hstack()` de la librería NumPy.
  • 🎨 Para transformar el espacio de color de una imagen de BGR a RGB, se utiliza la función `cv2.cvtColor()` con el argumento `cv2.COLOR_BGR2RGB`.
  • 📝 Se pueden crear imágenes que solo muestren un color específico al igualar a cero las capas no deseadas y concatenar estas imágenes para visualizar cada color individualmente.

Q & A

  • ¿Cómo se representan las imágenes en formato RGB en Python y OpenCV?

    -Las imágenes en formato RGB se representan en tres matrices bidimensionales correspondientes a cada uno de los planos o capas de la imagen: azul, verde y rojo.

  • ¿Cuál es la diferencia entre una imagen a color y una imagen a escala de grises en OpenCV?

    -Una imagen a color se representa con tres matrices correspondientes a los colores RGB, mientras que una imagen a escala de grises tiene una sola matriz que representa la luminosidad.

  • ¿Cómo se realiza la lectura de una imagen en OpenCV?

    -Para leer una imagen en OpenCV se utiliza la función `cv2.imread()`, donde se coloca el nombre de la imagen entre comillas y se puede especificar si se desea una imagen a color o a escala de grises mediante un argumento numérico.

  • ¿Qué función se utiliza en OpenCV para mostrar una imagen?

    -Para mostrar una imagen en OpenCV se utiliza la función `cv2.imshow()`, donde se coloca el título de la ventana y el nombre de la variable que contiene la imagen.

  • ¿Cómo se guarda una imagen en OpenCV?

    -Para guardar una imagen en OpenCV se utiliza la función `cv2.imwrite()`, donde se coloca el nombre y la extensión del archivo y el nombre de la variable que contiene la imagen.

  • ¿Qué función de OpenCV permite esperar cierto tiempo antes de cerrar una ventana de imagen?

    -La función `cv2.waitKey()` permite esperar cierto tiempo en milisegundos antes de cerrar una ventana de imagen. Si se coloca un 0, esperará hasta que se presione una tecla.

  • ¿Cómo se cierran todas las ventanas abiertas en OpenCV?

    -Para cerrar todas las ventanas abiertas en OpenCV se utiliza la función `cv2.destroyAllWindows()`.

  • ¿Qué es el espacio de color BGR y cómo se relaciona con el espacio RGB?

    -El espacio de color BGR es una representación de color utilizada en OpenCV donde los colores se ordenan en azul, verde y rojo, al revés del espacio RGB. Se puede convertir de BGR a RGB utilizando la función `cv2.cvtColor()`.

  • ¿Cómo se concatenan las capas de una imagen en OpenCV para mostrarlas juntas?

    -Para concatenar las capas de una imagen en OpenCV se utiliza la función `numpy.hstack()` para concatenar horizontalmente o `numpy.vstack()` para concatenar verticalmente.

  • ¿Cómo se obtienen las capas individuales de una imagen en OpenCV?

    -Para obtener las capas individuales de una imagen en OpenCV se accede a los índices correspondientes de la matriz de la imagen, donde el índice 0 corresponde al azul, el 1 al verde y el 2 al rojo.

Outlines

00:00

🖼️ Trabajando con imágenes y capas en Python

Este segmento del video tutorial se enfoca en cómo manipular imágenes y sus capas utilizando Python y OpenCV. Se explica que una imagen RGB se representa mediante tres matrices bidimensionales, una para cada canal de color (azul, verde y rojo). Al leer una imagen en Python con OpenCV, esta se almacena en formato BGR, con las capas indexadas desde 0 a 2. Se menciona la importancia de los valores numéricos de los píxeles, donde 0 representa negro y 255 representa blanco. Además, se presentan los comandos básicos de OpenCV para leer, mostrar y guardar imágenes, así como para pausar la ejecución del código y cerrar ventanas.

05:03

📂 Creando y ejecutando un script en Python

En este párrafo se describe el proceso de creación y ejecución de un script en Python para trabajar con imágenes. Se detalla cómo abrir un nuevo archivo en el editor de texto, activar la visualización de números de línea, importar la biblioteca OpenCV, y leer una imagen específica. Luego, se muestra cómo utilizar la función `cv2.imshow` para mostrar una imagen con un título específico y cómo pausar la ejecución con `cv2.waitKey`. También se explica cómo guardar una imagen en escala de grises y en color, y cómo cerrar todas las ventanas abiertas al final del proceso.

10:04

🌈 Obteniendo y mostrando capas de una imagen

Este segmento del tutorial se centra en cómo extraer y visualizar las capas individuales de una imagen en OpenCV. Se muestra cómo asignar cada capa de color (azul, verde, rojo) a variables diferentes y cómo utilizar la función `np.hstack` para concatenar estas capas horizontalmente en una sola imagen. Se menciona la necesidad de importar la biblioteca NumPy para realizar operaciones de concatenación de matrices. Además, se detalla el proceso de transformación de un espacio de color BGR a RGB y cómo mostrar las capas resultantes después de la transformación.

15:06

🎨 Visualización de colores individuales en una imagen

El último párrafo del script muestra cómo aislar y mostrar los colores individuales de una imagen utilizando Python y OpenCV. Se describe el proceso de crear copias de la imagen y manipular sus capas para mostrar únicamente el color azul, verde o rojo. Se utiliza la función `np.hstack` para concatenar las capas modificadas y se muestran las imágenes resultantes utilizando `cv2.imshow`. Finalmente, se cierra el proceso con `cv2.waitKey` y `cv2.destroyAllWindows`, y se invita al espectador a continuar aprendiendo sobre el manejo de imágenes en Python.

Mindmap

Keywords

💡Lectura y escritura de imágenes

La lectura y escritura de imágenes se refiere a la capacidad de un programa para cargar una imagen desde un archivo y guardar una imagen en un archivo. En el guion, esta es una de las primeras actividades que se discuten, destacando la importancia de manejar imágenes en formato RGB (rojo, verde y azul), que son representadas por tres matrices bidimensionales correspondientes a cada color.

💡Planos o capas de una imagen

Los planos o capas de una imagen son componentes individuales que componen una imagen en color. Cada capa representa la intensidad de un color específico: rojo, verde o azul. En el guion, se menciona que al leer una imagen en Python con OpenCV, se obtienen tres matrices bidimensionales, una para cada capa de color.

💡Matriz bidimensional

Una matriz bidimensional es una estructura de datos que contiene valores en una grilla rectangular. En el contexto del video, las matrices bidimensionales representan cada capa de color de una imagen en RGB. Cada elemento de la matriz corresponde a un píxel y su valor indica la intensidad del color en ese píxel.

💡Formato BCR

El formato BCR es una representación de color donde 'B' representa la capa de azul, 'C' la de verde y 'R' la de rojo. Aunque comúnmente se conoce como RGB, en OpenCV, las imágenes se leen por defecto en el formato BCR. Esto es relevante en el guion cuando se discute sobre cómo se indexan las capas de color al leer una imagen.

💡OpenCV

OpenCV (Open Source Computer Vision Library) es una biblioteca de software de código abierto para la computación de visión por computadora. En el guion, se utiliza OpenCV para realizar operaciones básicas de lectura, visualización y manipulación de imágenes, como se muestra en los ejemplos donde se lee y se muestra una imagen.

💡Función cv2.imread

La función cv2.imread se utiliza en OpenCV para cargar una imagen desde un archivo. Se menciona en el guion como el primer paso para trabajar con imágenes, donde se especifica el nombre de la imagen y se puede indicar si se desea una imagen a color o en escala de grises.

💡Función cv2.imshow

La función cv2.imshow se utiliza para mostrar una imagen en una ventana. En el guion, se usa esta función para visualizar la imagen leída y para demostrar cómo se pueden manipular las capas de color individualmente, poniendo de ejemplo cómo se puede mostrar una imagen en escala de grises o en color.

💡Espacios de color

Los espacios de color son modelos que definen cómo se representan los colores en una imagen digital. El guion habla sobre la transformación de un espacio de color BCR a RGB, que es un proceso de conversión de la representación de color por defecto en OpenCV a un formato más comúnmente utilizado.

💡Concatenación de matrices

La concatenación de matrices es el proceso de unir dos o más matrices de forma horizontal o vertical. En el guion, se utiliza la función np.hstack para concatenar las capas de color individualmente en una sola imagen, permitiendo visualizar cómo se ven cada una de las capas por separado.

💡Transformación de espacio de color

La transformación de espacio de color se refiere al proceso de convertir una imagen de un modelo de color a otro. En el guion, se discute cómo convertir una imagen de BCR a RGB, que es un paso importante para trabajar con imágenes en diferentes aplicaciones donde se requiere un modelo de color específico.

Highlights

Exploración de la lectura y escritura de imágenes en Python utilizando OpenCV.

Representación de imágenes RGB en tres matrices bidimensionales correspondientes a cada plano.

Las imágenes en Python y OpenCV se manejan en formato BGR por defecto.

Explicación de cómo las matrices bidimensionales representan los valores de cada capa de color.

Los valores numéricos en las capas representan los colores según la intensidad de cada píxel.

El valor cero en una capa representa el negro y 255 representa el blanco.

Combinación de colores para crear una variedad de tonos a partir de las capas.

Comandos principales de OpenCV para la manipulación de imágenes, como `cv2.imread` y `cv2.imshow`.

Recomendación de trabajar en la misma carpeta para facilitar la lectura de imágenes.

Uso de `cv2.waitKey` para esperar una acción del usuario antes de cerrar una ventana de imagen.

Cómo guardar una imagen utilizando `cv2.imwrite`.

Uso del comando `cv2.destroyAllWindows` para cerrar todas las ventanas abiertas.

Importación de la librería NumPy para manipular matrices y realizar operaciones matriciales.

Concatenación de matrices con `np.hstack` para mostrar varias capas en una sola imagen.

Conversión de espacios de color utilizando `cv2.cvtColor` para transformar de BGR a RGB.

Visualización de las capas individuales de una imagen para entender su composición en colores.

Creación de imágenes que solo muestran un color específico al igualar las otras capas a cero.

Demostración de la diferencia entre las capas de una imagen en BGR y RGB.

Conclusión del tutorial con una recapitulación de los conceptos y comandos aprendidos.

Transcripts

play00:00

saludos en esta ocasión veremos cómo

play00:02

podemos trabajar con la lectura y

play00:03

escritura de una imagen y en especial

play00:06

veremos cómo trabajar con los planos o

play00:08

capas de una imagen en python y open se

play00:10

ve lo primero que vamos a tomar en

play00:12

cuenta es que una imagen en formato de

play00:14

color rgb se representa en tres matrices

play00:17

bidimensionales correspondientes a cada

play00:19

uno de los planos o capas de nuestra

play00:21

imagen en el caso del trabajo de

play00:23

imágenes con python vamos a estar

play00:24

trabajando inicialmente con matrices los

play00:27

cuales representan a cada una de estas

play00:29

capas pero en el formato bcr por lo

play00:32

tanto una vez que nosotros realizamos la

play00:34

lectura de una imagen esta x de favor se

play00:36

encontraría en el formato br en el caso

play00:39

de python y open se ve al realizar la

play00:42

lectura de estas imágenes tendríamos

play00:44

inicialmente indexadas la primera capa

play00:46

la matriz de la imagen en azul

play00:49

posteriormente la segunda capa la matriz

play00:51

del color verde y la tercera capa la

play00:53

matriz del color rojo indexadas desde el

play00:56

número 0 1 y 2 recordemos que cuando

play00:59

realizamos la lectura de una imagen y la

play01:01

descomponemos en cada una de sus capas

play01:03

lo que

play01:04

tendríamos son prácticamente matrices

play01:06

bidimensionales los cuales nos indican

play01:08

los valores de cada una de esas capas y

play01:11

en conjunto cada uno de esos valores

play01:13

estaría formando cada uno de esos

play01:15

colores de acuerdo a la intensidad de

play01:17

cada pixel en cada una de sus capas

play01:19

podemos ver un ejemplo de la lectura de

play01:22

esta imagen en donde se representa por

play01:25

medio de rgb y cada uno de esos valores

play01:27

numéricos representa el color de nuestra

play01:30

imagen por otra parte una imagen

play01:32

correspondiente a la letra a cuando

play01:34

realizamos la lectura y descomponemos

play01:36

esta imagen estaría representada en cada

play01:39

uno de sus píxeles por estos valores

play01:42

numéricos debemos de tomar en cuenta que

play01:44

cuando tenemos en cada una de estas

play01:46

capas el valor cero éste correspondería

play01:48

al valor negro y en el caso de que

play01:51

tengamos 255 en cada una de esas capas

play01:54

en conjunto correspondería a un color

play01:57

blanco posteriormente cuando se realiza

play01:59

la combinación de cada uno de estos

play02:01

colores podemos realizar y conformar la

play02:03

diversidad o variedad de colores que

play02:06

nosotros querramos los comandos

play02:07

principales que vamos a utilizar para la

play02:09

de imágenes en open tv inicialmente

play02:13

colocando cb 2.1 reach y con este

play02:16

comando estaríamos realizando la lectura

play02:18

de una imagen y dentro de paréntesis en

play02:21

comillas simples estaríamos colocando el

play02:23

nombre de la imagen con la extensión que

play02:25

queremos leer separado por coma el valor

play02:28

numérico 0 o 1 correspondiente a el tipo

play02:31

de imagen que queremos obtener si no

play02:33

colocamos este argumento por default

play02:35

el comando nos estaría devolviendo una

play02:37

imagen a color y si colocamos un 0 nos

play02:40

estaría devolviendo una imagen a escala

play02:43

de grises por lo tanto si coloco yo un 1

play02:45

obtengo una imagen a color y si coloco

play02:48

un 0 obtengo una imagen en escala de

play02:50

grises es recomendable trabajar dentro

play02:52

de una misma carpeta es decir tanto la

play02:55

imagen con la que estamos trabajando y

play02:56

el archivo de código con el cual estamos

play02:59

trabajando se encuentran dentro de la

play03:00

misma carpeta de esta manera solamente

play03:03

vamos a colocar el nombre de la imagen

play03:05

para poder leer nuestro archivo en otro

play03:07

caso si no se tiene la imagen en la

play03:09

misma carpeta en donde se está

play03:11

ejecutando mi archivo de código se puede

play03:14

realizar la lectura de la imagen

play03:16

por medio de la ruta absoluta dentro de

play03:18

nuestro equipo colocando diagonales

play03:20

dobles para que ésta pueda ser tomada en

play03:22

cuenta y una vez que nosotros hemos

play03:24

leído nuestra imagen podemos mostrarla

play03:26

con el comando c b2 punto in show y

play03:29

dentro de paréntesis vamos a colocar

play03:32

primero dentro de comillas simples o

play03:33

apostrophes el título de la ventana en

play03:36

donde vamos a mostrar nuestra imagen y

play03:38

posteriormente separado por coma vamos a

play03:40

indicar el nombre de la variable en

play03:42

donde se encuentra la imagen que

play03:44

queremos mostrar si deseamos guardar una

play03:46

imagen podemos utilizar el comando que

play03:48

se ve dos puntos

play03:50

write y dentro de paréntesis vamos a

play03:52

colocar primero dentro de comillas

play03:54

simples o apostrophes el nombre con el

play03:56

cual queremos guardar nuestro archivo

play03:57

junto con su extensión y separado por

play04:00

coma el nombre de la variable en donde

play04:02

se encuentran la información de nuestra

play04:04

imagen finalmente vamos a estar

play04:05

utilizando el comando cb2 weiqi y entre

play04:09

paréntesis vamos a poder colocar un

play04:11

valor en milisegundos esta línea de

play04:13

comando nos va a permitir esperar cierto

play04:15

tiempo y posteriormente estaría cerrado

play04:18

en el caso de que nosotros coloquemos un

play04:21

valor cero dentro de paréntesis una vez

play04:23

que nosotros ejecutemos el código y este

play04:25

muestra en nuestra imagen por medio de

play04:27

una tecla estaría terminando nuestro

play04:29

código y finalmente en la última línea

play04:31

estaríamos cerrando todas las ventanas

play04:34

abiertas algunos otros comandos que

play04:36

vamos a utilizar en este vídeo son los

play04:38

comandos para concatenar o transformar

play04:40

en los diferentes espacios de color para

play04:42

utilizar el comando para concatenar aquí

play04:45

está esta vamos primero a realizar la

play04:47

importación de la librería de lampe de

play04:50

esta manera y posteriormente podemos

play04:52

agregar un alias para poder ocupar de

play04:54

una forma abreviada las funciones de

play04:57

nanping en este caso importamos a noam y

play04:59

como en ep ya teniendo este alias en ep

play05:02

vamos a utilizar el comando h stack obed

play05:05

stack

play05:06

lo cual nos va a permitir concatenar de

play05:08

forma horizontal o bien de forma

play05:10

vertical las matrices que nosotros

play05:12

queremos para posteriormente mostrarlas

play05:14

como imagen finalmente con esta última

play05:17

línea vamos a poder transformar nuestra

play05:20

imagen a los diferentes espacios de

play05:21

color en este ejemplo estamos

play05:23

convirtiendo una

play05:24

en el espacio de color br a rgb

play05:27

iniciando con se ve dos puntos se ve te

play05:30

color y dentro de paréntesis vamos a

play05:32

colocar el nombre de la variable que

play05:34

contiene la imagen en cierto espacio de

play05:37

color y posteriormente con cb2 punto

play05:40

color y un bajo y este apartado nosotros

play05:43

lo podemos cambiar para determinar la

play05:45

transformación o para convertir el

play05:47

espacio de color y bien vamos a realizar

play05:49

unos ejemplos

play05:50

compay ton y open se ve bien para

play05:53

comenzar ha generado una carpeta con el

play05:55

nombre de open se ve en el escritorio la

play05:57

cual solamente contiene estas tres

play06:00

imágenes para iniciar voy a seleccionar

play06:02

el edil de payton en esta opción desde

play06:05

inicio y una vez ingresando voy a

play06:08

presionar control n o bien puedo

play06:10

seleccionar la opción file y new file

play06:13

podemos observar que nos indica que se

play06:15

puede abrir un nuevo archivo con control

play06:17

n por lo tanto yo voy a presionar

play06:19

control n estoy generando un nuevo

play06:21

archivo y voy a colocar estas dos

play06:23

ventanas a la mitad de mi pantalla antes

play06:26

de comenzar

play06:26

voy a activar la opción de mostrar el

play06:28

número de líneas

play06:29

ahora comenzando voy a importar a open

play06:32

seven con import v2 una vez realizado

play06:35

esto voy a crear la variable img y con

play06:38

la función de 2.100 ruiz dentro de

play06:42

paréntesis y comillas simples o

play06:44

apostrophes voy a colocar el nombre de

play06:46

la imagen que deseo leer en este caso

play06:49

voy a comenzar con la imagen con el

play06:51

nombre de 12.8 y no voy a indicar el

play06:55

segundo argumento ahora utilizando la

play06:58

función cb2 punto y show dentro del

play07:01

paréntesis lo primero que voy a colocar

play07:03

es el título de la ventana en este caso

play07:05

colocaré imagen de una rosa y separado

play07:08

por coma tengo que indicar el nombre de

play07:10

la variable en el cual se aloja la

play07:12

imagen en este caso es img ya realizado

play07:15

esto ahora voy a utilizar la función cb2

play07:17

punto white y dentro de paréntesis voy a

play07:20

colocar un cero recordemos que esta

play07:22

función le tenemos que pasar valores en

play07:24

milisegundos y si colocamos un cero

play07:27

estaría esperando que nosotros

play07:28

presionemos una tecla para terminar el

play07:30

proceso y posteriormente vamos a cerrar

play07:33

las ventanas por lo tanto voy a colocar

play07:35

pero ahora utilizando la función se ve

play07:37

dos punto destruyó el windows estaríamos

play07:40

cerrando todas nuestras ventanas bien

play07:42

ahora antes de ejecutarlo voy a guardar

play07:44

mi archivo justamente en esta misma

play07:47

carpeta que se ubica en mi escritorio

play07:51

con el nombre de ejemplo capas a esto le

play07:55

podemos agregar la extensión punto pay o

play07:57

podemos guardarlo directamente y se

play07:59

estaría guardando con la extensión punto

play08:01

país voy a dar en guardar observamos que

play08:03

ya se ha guardado justamente en donde se

play08:06

encuentran también las imágenes que voy

play08:07

a utilizar y ahora ubicado en la ventana

play08:10

de payton puedo seleccionar la opción de

play08:13

room o bien puedo presionar la tecla f5

play08:16

para ejecutar mi código por lo tanto yo

play08:18

voy a presionar efe 5 en este momento ya

play08:21

me está mostrando la imagen que estoy

play08:23

leyendo y también podemos observar que

play08:26

el título de la ventana contiene

play08:28

justamente

play08:28

imagen de una rosa que por el tamaño no

play08:31

se puede observar completamente como

play08:33

estamos utilizando la función wake y al

play08:35

presionar cualquier tecla de mi teclado

play08:36

esta ventana se cerraría por lo tanto

play08:39

voy a presionar la barra de espacio se

play08:41

está cerrando y finalmente con la última

play08:43

línea se cierran todas las ventanas

play08:45

abiertas también se observa que el

play08:47

segundo argumento del comando y enric no

play08:50

lo he colocado por lo tanto me estaba

play08:52

mostrando una imagen a color ahora

play08:54

separado por coma voy a colocar

play08:56

el número 1 lo cual me estaría mostrando

play08:58

nuevamente la imagen a color voy a

play09:00

presionar

play09:01

efe 5 y correr el código lo guardo y

play09:05

nuevamente podemos observar nuestra

play09:07

imagen presiono cualquier tecla para

play09:09

cerrar esta ventana y terminar la

play09:10

ejecución de nuestro código ahora si yo

play09:12

modificó este segundo argumento y colocó

play09:15

un valor 0 esto me estaría devolviendo

play09:17

una imagen a escala de grises nuevamente

play09:20

presione f5 y enter para guardar los

play09:23

cambios aquí ya tenemos el resultado en

play09:26

donde observamos la imagen en escala de

play09:29

grises ahora aprovechando este cambio a

play09:32

escala de grises voy a utilizar el

play09:35

comando se ve dos puntos el right para

play09:38

guardar la imagen en escala de grises y

play09:40

dentro de paréntesis dentro de comillas

play09:42

simples o apostrophes voy a colocar el

play09:44

nombre y la extensión de mi imagen la

play09:47

voy a guardar como rosa punto png y

play09:49

ahora separado por coma tengo que

play09:51

indicar el nombre de la variable en

play09:53

donde se aloja la imagen que quiero

play09:55

guardar en este caso la variable es img

play09:58

previamente observamos dentro del

play10:00

contenido de la carpeta

play10:01

que no se encuentra la imagen en escala

play10:03

de grises y ahora al ejecutar mi código

play10:06

presionando f 5 me está mostrando la

play10:09

imagen a escala de grises y al mismo

play10:11

tiempo me estaría guardando una imagen

play10:14

con el nombre de rosa y la extensión

play10:16

punto png presiono cualquier tecla para

play10:19

cerrar esta ventana y estaría terminando

play10:21

mi proceso ahora voy a comentar esta

play10:23

línea en donde guardo la imagen en

play10:25

escala de grises con el símbolo del

play10:27

numeral o gato bien ahora lo siguiente

play10:29

que voy a realizar es obtener cada una

play10:31

de las capas o niveles de mi imagen

play10:33

recordando que una vez que obtengo una

play10:35

imagen con open se ve esta estaría por

play10:38

default en el formato b xerez por lo

play10:40

tanto iniciando con la variable b la voy

play10:42

a igualar a mi variable img de la cual

play10:45

voy a obtener todas las filas todas las

play10:48

columnas de la primera capa que es la

play10:50

capa 0 con este mismo código voy a

play10:53

utilizar la variable g

play10:55

pero ahora obteniendo la segunda capa

play10:58

con el índice 1 y ahora con la variable

play11:00

ere estaría obteniendo la tercera capa

play11:03

con el índice 2 y para poder mostrar

play11:06

cada una de estas capas

play11:07

o matrices de mi imagen voy a tener que

play11:09

concatenar las y mostrarlas en una sola

play11:11

imagen previamente voy a importar la

play11:14

librería de nombre utilizando import

play11:16

nombre

play11:17

np recordemos que este último solamente

play11:20

es un alias con el cual vamos a utilizar

play11:23

las funciones de nube y generalmente se

play11:25

utiliza np sin embargo este último puede

play11:28

cambiar a conveniencia he realizado esto

play11:31

ahora voy a generar una variable llamada

play11:33

vgr y utilizando la función de nanping

play11:36

voy a colocar n punto h stack y dentro

play11:40

de paréntesis y corchetes

play11:42

voy a concatenar la matriz b/g y r ahora

play11:45

lo que voy a hacer es mostrar la imagen

play11:47

concatenada de cada una de estas capas

play11:50

utilizando la función cb2 punto y el

play11:53

show dentro del paréntesis colocó un

play11:55

título y separado por coma agregó el

play11:58

nombre de la variable que es bcr ya ha

play12:01

realizado esto voy a presionar f5 para

play12:03

correr mi código presionó enter para

play12:05

guardarlo me está mostrando un error

play12:08

ya que no he realizado el cambio y en

play12:10

este momento tengo una imagen en escala

play12:13

de grises la cual solamente tiene un

play12:15

solo nivel por lo tanto voy a colocar el

play12:18

valor 1 para obtener una imagen a color

play12:20

y posteriormente esta imagen a color se

play12:23

estaría descomponiendo en cada una de

play12:25

sus capas nuevamente presione f5 enter

play12:28

para guardar y bien podemos observar

play12:31

cada una de esas capas de nuestra imagen

play12:34

original las cuales corresponderían al

play12:36

color azul verde y rojo lo que sería el

play12:39

bcr respectivamente presiono cualquier

play12:42

tecla para terminar mi proceso y cerrar

play12:44

las ventanas y bien ahora lo siguiente

play12:46

que voy a realizar es una conversión en

play12:48

el espacio de color pasando de vgr a rgb

play12:52

para esto voy a utilizar la variable rgb

play12:55

igualada al comando se ve 2.7 color y

play12:59

dentro del paréntesis voy a colocar la

play13:01

variable que contiene la imagen que

play13:03

deseo transformar en este caso la

play13:05

variable es img que contiene la imagen

play13:08

en vejer separado por coma voy a

play13:10

utilizar el comando c2 punto color guión

play13:13

bajo

play13:14

r tú rgb y con esto estaría realizando

play13:17

la transformación del espacio de color

play13:19

vgr

play13:20

rgb ahora simplemente voy a copiar estas

play13:23

líneas de la parte de arriba y voy a

play13:26

cambiar las variables a rgb tomando r1

play13:31

g1 y b 1 y en este caso estaría tomando

play13:34

la variable rgb

play13:37

nuevamente con la variable rgb 1

play13:39

utilizando la función de nunca h stack

play13:42

concatenó la variable r 1 g 1 y b1

play13:46

correspondientes a las capas rgb

play13:48

finalmente las muestro con cb 2 el show

play13:51

y el nombre de la ventana será capas 2 y

play13:54

la variable a mostrar es rgb nuevamente

play13:57

presione f5 para ejecutar mi código bien

play14:01

podemos observar ahora que tenemos en

play14:03

esta imagen la descomposición de las

play14:06

capas en esta imagen estamos mostrando

play14:08

la imagen original y en esta imagen

play14:11

estamos mostrando la imagen en rgb sin

play14:14

embargo ahora voy a mostrar la imagen de

play14:17

cada una de las capas de la

play14:19

transformación a rgb por lo tanto mi

play14:22

variable sería rgb 1 en donde se

play14:24

encuentran concatenadas cada una de esas

play14:26

capas presiona f5 y enter y bien ahora

play14:30

podemos observar la diferencia entre

play14:33

cada una de esas capas en donde podemos

play14:36

observar en la parte superior las capas

play14:39

del bcr y en la segunda imagen nombrada

play14:42

como capas 2 tenemos

play14:43

las capas correspondientes al rgb voy a

play14:46

cambiar la imagen que estoy utilizando

play14:48

por la imagen de rgb png realizado esto

play14:53

presiona f5 bien podemos observar ahora

play14:56

la diferencia correspondiente a nuestra

play14:59

imagen original en donde en la primera

play15:01

se está mostrando como primer capa la

play15:03

capa del color azul correspondiente a

play15:06

este círculo en la segunda se está

play15:08

mostrando la capa correspondiente al

play15:11

color verde y el color rojo en la parte

play15:14

inferior podemos observar que cada una

play15:16

de las posiciones de estas capas

play15:18

corresponde justamente a la posición de

play15:21

la imagen en rgb ya que tenemos primero

play15:24

la capa roja

play15:25

posteriormente la capa verde y

play15:27

finalmente la capa azul bien finalmente

play15:31

voy a mostrar en una imagen cada uno de

play15:33

los colores correspondientes utilizando

play15:35

el formato vgr por lo tanto voy a borrar

play15:38

esta parte y ahora utilizando cada una

play15:41

de estas capas voy a igualar a cero dos

play15:43

de las capas para mantener solamente un

play15:45

color y bien finalmente ya tengo el

play15:48

código en donde

play15:49

importado la librería copy para realizar

play15:52

justamente copias de la variable en

play15:55

donde se aloja la imagen asociadas a las

play15:57

variables vgr posteriormente en cada uno

play16:01

de estos apartados estoy igualando a

play16:03

cero las capas del bcr y solamente estoy

play16:06

dejando con los valores originales

play16:08

aquella capa del color que quiero

play16:10

mostrar en la primera capa estoy dejando

play16:12

solamente la capa del color azul

play16:15

posteriormente la capa del color verde y

play16:17

la capa del color rojo

play16:19

finalmente concatenó cada una de estas

play16:20

imágenes con n punto h está colocando la

play16:25

capa del color azul

play16:26

posteriormente la verde y finalmente la

play16:28

roja en la siguiente línea muestro la

play16:30

imagen que contiene ya cada una de estas

play16:32

imágenes mostrando solamente cada uno de

play16:35

esos colores terminando con la línea de

play16:37

waikiki que espera para presionar una

play16:40

tecla y terminar el proceso y finalmente

play16:42

cerrar todas las ventanas por lo tanto

play16:44

voy a presionar f5 y a ejecutar el

play16:47

código bien podemos observar que se está

play16:51

separando correctamente cada una de

play16:52

estas capas correspondientes al bcr

play16:55

y se está mostrando correctamente cada

play16:58

uno de esos colores bien por este vídeo

play17:00

ha sido todo hasta luego

play17:03

el agua

Rate This

5.0 / 5 (0 votes)

Related Tags
OpenCVPythonImágenes DigitalesRGBColorProgramaciónManejo de ImágenesProcesamiento de ImágenesTutorialCodificación
Do you need a summary in English?