vimeo.com/.../935097022

E chegou a hora
de pôr a mão na massa

e entender como que a gente consegue
usar essas ferramentas computacionais

para codificar uma imagem

e fazer o processamento
dessa imagem de forma digital.

E a ferramenta que a gente
vai utilizar é a OpenCV.

OpenCV nos dias atuais

é uma das ferramentas
de processamento de imagem

mais difundidas no mercado.

Você pode até trabalhar
com outras ferramentas,

mas, fatalmente, você vai ter
que fazer alguma interface

usando os recursos
que a ferramenta da OpenCV,

essa biblioteca que a gente vai trabalhar,
consegue te oferecer.

Não só essa biblioteca, vamos
trabalhar também com o Matplotlib.

Essa biblioteca, Matplotlib,

a gente utiliza bastante
para plotar gráficos.

E a gente vai ver como
que a gente pode usar essa ferramenta,

essa biblioteca, para exibir imagens.

Sem mais delongas,
vamos botar a mão na massa.

Eu estou no meu ambiente Visual Code,
utilizando o Jupyter,

para poder escrever
os nossos notebooks.

E aqui, eu já tenho instalado
e configurado o meu OpenCV.

Eu vou executar ele.

Como que a gente vai trabalhar
com o nosso OpenCV?

Utilizando o Jupyter,
a gente vai fazer o seguinte.

A gente vai dar um import da CV2.

Então, o OpenCV, essa biblioteca,
a gente chama ela,

a gente importa ela
com o apelido de CV2.

A gente vai passar um caminho
para uma imagem.

Eu sugiro que você tenha a imagem
já salva no mesmo diretório,

onde você tem
esse Jupyter Notebook rodando.

Porque isso vai facilitar na hora
de fazer o método inRead,

que é. imageRead,
onde a gente vai ler uma imagem.

Então, ele é um método da CV2.

Depois, a gente passa esse caminho
da imagem que a gente vai trabalhar.

A imagem que a gente
vai trabalhar é alena.png.

E a gente vai mandar
exibir essa imagem.

Para exibir essa imagem,
a gente usa o recurso de cv2.inShow,

ou imageShow.

A gente define uma janela.

Então, ele vai abrir
um pop-up aqui para a gente.

E a gente fala o que a gente quer
que apareça nesse pop-up,

que é a nossa imagem.

Então, a gente passa aqui
o argumento da imagem

que a gente acabou de carregar.

Aqui no finalzinho,
eu coloquei um delayzinho.

Dentro da OpenCV,
a gente tem esse comando aqui,

esse recurso chamado WaitKit.

Onde ele fica esperando
a gente pressionar uma tecla.

No caso, a tecla que ele está esperando
eu pressionar é a tecla Esc.

Quando der esse Esc, ele vai
fechar para a gente o nosso código.

Vamos rodar o nosso comando
e ver a nossa imagem aparecer.

Executei aqui a nossa célula.

Ele está executando o nosso comando.

Quando a gente dá Alt + Tab,

apareceu aqui a nossa modelo
chamada Lena.

Para a gente fechar essa janela,

a gente tem que dar Esc
no nosso código.

Repare que ele fechou o comando
que a gente executou no notebook.

Mas a tela não fechou.

E aqui ele fica travado.

Então, da forma como a gente
tenta exibir a imagem

usando o Jupyter Notebook,
não é recomendável.

Então, a gente fecha esse processo.

Funciona muito bem
se a gente criar um arquivo Python.

Então, se a gente tiver o nosso arquivo
aqui, o mesmo código,

só que agora rodando aqui
no nosso arquivo .py,

a gente pode executar ele.

Ele vai abrir a nossa imagem.

E aí sim, como um arquivo Python,
ele não vai travar.

A gente consegue executar
ele numa boa.

Então, minha sugestão,

e a sugestão de quem trabalha
com visão computacional

e processamento de imagem,

é a gente não usar
para exibir o WinShow

quando a gente estiver rodando
com o Jupyter.

A gente vai usar a biblioteca
do Matplotlib para realizar essa tarefa.

Então, a gente começa importando
o OpenCV da mesma forma.

A gente vai importar
também o Matplotlib.

Só que do Matplotlib,

a gente não vai importar toda
a biblioteca do Matplotlib.

A gente vai importar apenas
o que a gente precisa

para exibir essas imagens,
que é o Pyplot.

Para não ficar um comando muito grande,
é habitual e comum

a gente dar um apelido
para Matplotlib.pyplot, que é PLT.

Então, toda hora que você vê PLT
ponto alguma coisa,

a gente está fazendo referência
ao Matplotlib.pyplot.

Vamos executar.

Eu vou dar um restart no meu kernel.

Ele vai restartar aqui.

Eu vou zerar ele, porque ele crashou
quando a gente executou da última vez.

Beleza.

Executei minha célula.

Importei aqui no meu kernel
do Python o OpenCV e o Matplotlib.

Agora, a gente tem um comandinho
mágico, que é o %MATplotlib.inline.

Esse comando é bem importante,
a gente não pode esquecer,

porque é com ele que a gente vai conseguir
executar o nosso notebook

e fazer com que as imagens apareçam
não como um pop-up,

mas como um item dentro
da nossa janela do notebook.

Vamos executar ele.

A gente consegue rodar ele

e a gente vai fazer
tudo exatamente igual.

Só que, note que agora,
na hora de exibir a imagem de saída,

a gente vai usar o PLT.

Então, PLT.inShow é o comando
que a gente vai usar

para poder exibir a nossa imagem.

Depois do InShow,
a gente vai dar o PLT.show,

que é para ele exibir essa imagem.

Então, note que agora a gente já
conseguiu carregar a nossa imagem.

Executamos a nossa célula
aqui do Júpiter

e não tivemos problema.

A única coisa que está
um pouquinho esquisita aqui,

e você vai concordar comigo,

é que a lenda
está um pouco azulada, né?

Ela não tem essa cor naturalmente.

Alguma coisa aconteceu.

Então, o que aconteceu?

É que no início dos anos 2000,

quando a OpenCV foi escrita
e foi lançada,

ela foi padronizada com
a seguinte concatenação de canal.

BGR.

Anos depois, quando o Matplotlib foi
lançado, ele foi pensado, escrito

e estruturado com a seguinte
concatenação de cor.

R, G e B.

Note aí que a gente tem
uma inversão dos canais.

Na OpenCV,
o primeiro canal de cor é azul.

Já para o Matplotlib,
é o canal vermelho.

No nosso dia a dia,
a gente está muito mais habituado

a trabalhar com a escala de cor RGB.

Mas, quando a gente mescla esses
dois mundos, essas duas bibliotecas,

a gente tem que prestar atenção
se a gente está trabalhando

com as cores em BGR ou em RGB.

Então, o que a gente precisa fazer
para deixar a lenda menos azul

e trabalhar com essas duas bibliotecas
de forma coerente,

é fazer a conversão de cor.

A gente já tem na biblioteca um método
para isso, que chama CVTColor.

Vamos ver como que a gente aplica
ele na nossa imagem

para poder fazer a impressão
e a exibição correta da lenda.

Aqui, a gente não mudou nada.

A gente continua carregando
a lenda da mesma forma.

Só que o nosso método
agora da CV2 é o CVTColor.

A gente tem dois argumentos
para ele.

O primeiro é a imagem de entrada.

A imagem que a gente está passando

é a imagem que a gente
acabou de carregar.

O segundo argumento é a forma
como a gente vai converter essa cor.

A gente tem uma cor que a gente
acabou de carregar com a OpenCV.

Essa imagem,

ela está no padrão de cor BGR
e a gente quer converter ele para, então,

true RGB.

Então, usando o CVTColor e passando
para ele que a imagem original

está em BGR e a gente quer converter
ela para RGB, esse método CVTColor,

ele vai devolver uma imagem
que vai ser em RGB.

Com a imagem RGB,
não tem problema nenhum.

Agora a gente vai conseguir exibir
a lenda da sua cor

e da forma que deveria ser.

Fizemos nosso Hello World
do mundo de visão computacional

e processamento de imagens.

Já entendemos que a OpenCV
é o benchmark do mercado

e é a forma como as maiores empresas
que trabalham nesse segmento,

nesse nicho, usam para poder fazer
o processamento de imagem.

Uma ferramenta muito útil quando
a gente está utilizando a OpenCV

para estruturar os nossos códigos
usando o Jupyter

é usar o Matplotlib
para exibir essas imagens

de forma mais simplificada.

Agora que você já entendeu
como que a gente consegue

carregar uma imagem
e converter ela de cor,

fica como desafio você carregar
e importar uma imagem sua.

Que tal você tirar uma foto
e importar ela dentro da OpenCV?