Minicurso de processamento de imagem com Python e OpenCV (1ª SECOMP)

Imagens digitais Sistemas de cores Transformações Efeitos de cores Histograma e equalização de intensidades Filtros convolucionais Limiarização e B
Processamento de imagens digitais
1a semana de engenharia da computação
Filipe Chagas
Universidade Federal de Mato Grosso
FAENG
October 4, 2019
Filipe Chagas UFMT - FAENG Processamento de imagens digitais October 4, 2019 1 / 79

Sumário
1 Imagens digitais
2 Sistemas de cores
3 Transformações
4 Efeitos de cores
5 Histograma e equalização de intensidades
6 Filtros convolucionais
7 Limiarização e Binarização
8 Segmentação de bordas
9 Detecção de objetos

Pasta do drive com os arquivos
Acesse a pasta do Google Drive com os arquivos deste minicurso através desta URL:
http://abre.ai/akdc

Imagens digitais

Como uma imagem é representada digitalmente?
Uma imagem digital consiste de uma matriz bi-dimensional de pixels.
O produto Altura × Largura da matriz é o que chamamos de Resolução da imagem,
onde a Altura é o total de linhas da matriz, e a Largura é o total de colunas da matriz.
fonte: https://www.flickr.com/photos/84568447@N00/4564124991
Os pixels são elementos que definem as cores em cada ponto da imagem.

(OpenCV) Trabalhando com imagens
Primeiramente, é necessário carregar as bibliotecas que serão utilizadas em nosso
programa:
Carregar o OpenCV
import cv2
Carregar o NumPy
import numpy as np
Se uma dessas duas linhas de código causou algum erro, o OpenCV provavelmente
não esta corretamente instalado no seu ambiente de desenvolvimento.

Para criar uma imagem totalmente preta ou branca, podemos utilizar um dos seguintes
comandos:
Criar uma imagem 500 x 500 preta
imagem = np.zeros(shape=[500, 500, 3],
dtype=np.uint8)
Esta linha de código cria uma matriz de bytes do numpy, de dimensões 500 x
500 x 3, totalmente preenchidas com 0.
Criar uma imagem 500 x 500 branca
imagem = 255 * np.ones(shape=[500, 500, 3],
dtype=np.uint8)
Esta linha de código cria uma matriz de bytes do numpy, de dimensões 500 x
500 x 3, totalmente preenchidas com 1. Com um produto pelo escalar 255, se
torna uma matriz preenchida com 255 (o valor máximo de um byte).

Para carregar um arquivo de imagem, podemos utilizar o seguinte comando:
Carregar o arquivo flores.jpg
imagem = cv2.imread("flores.jpg")
Esta linha de código cria uma matriz de bytes do numpy, similar as matrizes
que criamos anteriormente com as funções np.zeros e np.ones. A matriz é
preenchida com o conteúdo da imagem do arquivo carregado.
Salva imagem em arquivo flores2.jpg
cv2.imwrite("flores2.jpg", imagem)

Para vizualizar uma imagem, podemos utilizar os seguinte comando:
Criar uma janela de vizualização
cv2.imshow("nome da janela", imagem)
Esta linha de código prepara a janela que será usada para mostrar a imagem
contida na matriz.
Mostrar a janela até o usuário fecha-la
cv2.waitKey(0)
Esta linha de código faz a janela que criamos com a função imshow aparecer.
A execução do programa fica parada nesta linha de código até o usuário fechar a
janela.

Para obter as dimensões de uma imagem, podemos utilizar os seguinte comando:
Obter total de linhas (altura)
nlinhas = imagem.shape[0]
Obter total de colunas (largura)
ncolunas = imagem.shape[1]

Sistemas de cores

Pixels e sistema RGB
Um pixel é um pequeno vetor de informações que descrevem a cor do ponto na
imagem por meio de um sistema de cores.
O sistema de cores mais simples é o RGB.
fonte: https://en.wikipedia.org/wiki/RGB_color_model/media/File:AdditiveColor.svg
Neste sistema, as cores são representadas como combinações das luzes vermelha,
verde e azul.
Um pixel, no sistema RGB, é um vetor de pelo menos 3 valores numéricos, que
definem, respectivamente, a intensidade da luz vermelha, a intensidade da luz verde, e
a intensidade da luz azul.

Sistema HSV
Outro exemplo de sistema de cores é o sistema HSV. Nele, as cores são represen-
tadas por três parâmetros: Hue (Matiz), Saturation (Saturação) e Value (Valor).
Fonte: https://commons.wikimedia.org/wiki/File:HSV_color_solid_cylinder_saturation_gray.png
Os parâmetros têm a seguinte interpretação:
A Matiz (HUE) representa a tonalidade da cor. O espectro de cores é
representado como um circulo, e o HUE é o ângulo da coordenada polar da cor
neste circulo.
O Saturação (Saturation) representa a "pureza" da cor.
O Valor (Value) representa a maior intensidade dentre as três intensidades R, G
e B.

Sistema HSV
Os parâmetros HSV podem ser calculados a partir dos parâmetros R, G e B, da seguinte
forma:
1 Normalização:
h
r g b
i
=
1
R + G + B
h
R G B
i
(1)
2 Valor (Value):
V = max(r, g, b) (2)
3 Saturação (Saturation):
S =
(
0, V = 0
V −
min(r,g,b)
V
, V > 0
(3)
4 Matiz (HUE):
H =









0o, S = 0
60o × g−b
S×V
, V = r
60o × (2 + b−r
S×V
), V = g
60o × (4 + r−g
S×V
), V = b
(4)
Obs: se H < 0, o valor H deve ser alterado para H = H + 360

Sistema HSL
Outro exemplo de sistema de cores é o sistema HSL. Nele, as cores são represen-
tadas por três parâmetros: Hue (Matiz), Saturation (Saturação) e Lightness (Luminosi-
dade).
Fonte: https://commons.wikimedia.org/wiki/File:HSL_color_solid_cylinder_saturation_gray.png
Os parâmetros H, S e L são interpretados de forma parecida com os parâmetros
do sistema HSV. Porém, a forma como os parâmetros HSL são calculados em função
dos valores R, G e B, é diferente da forma como os parâmetros do sistema HSV são
calculados.

Sistema HSL
Os parâmetros HSL podem ser calculados a partir dos parâmetros R, G e B, da seguinte
forma:
1 Normalização e diferença max-min :
h
r g b
i
=
1
R + G + B
h
R G B
i
(5)
∆ = max(r, g, b) − min(r, g, b) (6)
2 Luminosidade (Lightness):
L =
max(r, g, b) + min(r, g, b)
2
(7)
3 Saturação (Saturation):
S =
(
0, ∆ = 0
∆
1−|2L−1|
, ∆ > 0
(8)
4 Matiz (HUE):
H =









0o, ∆ = 0
60o × g−b
∆
, max(r, g, b) = r
60o × (2 + b−r
∆
), max(r, g, b) = g
60o × (4 + r−g
∆
), max(r, g, b) = b
(9)
Obs: se H < 0, o valor H deve ser alterado para H = H + 360

Sistemas de cores no OpenCV
Quando carregamos um arquivo de imagem com a função imread, o OpenCV cria
um array do numpy de 3 dimensões. A primeira dimensão corresponde à altura da
imagem (quantidade de linhas do array). A segunda, à largura da imagem (quantidade
de colunas do array). A terceira contém os parâmetros da cor de cada pixel em um
determinado sistema de cores.
O OpenCV utiliza, por padrão, o sistema BGR (RGB de trás pra frente). Nele, os
índices 0, 1 e 2 da terceira dimensão da matriz correspondem, respectivamente, às
intensidades das cores azul, verde e vermelha.
Exemplo
imagem = cv2.imread(’arquivo’)
imagem[linha,coluna,:] = (B, G, R)
imagem[linha,coluna,0] = azul
imagem[linha,coluna,1] = verde
imagem[linha,coluna,2] = vermelho

Sistemas de cores no OpenCV
O OpenCV também suporta outros sistemas de cores. Podemos converter um array
de um sistema de cores para outro utilizando a função cv2.cvtColor().
Exemplo
imagemHSV = cv2.cvtColor(imagem, cv2.COLOR_BGR2HSV)
imagemHSV[linha, coluna, :] = (H,S,V)
Exemplo
imagemBGR = cv2.cvtColor(imagem, cv2.COLOR_HSV2BGR)
imagemBGR[linha, coluna, :] = (B,G,R)
Porém, a função cv2.imshow() só exibe imagens no padrão BGR ou em uma escala
de cinza. Caso a imagem esteja codificada no array em um sistema de cores diferente,
como o HSV, o LAB ou o LUV, a função cv2.imshow() irá mostrar a imagem em uma
coloração distorcida.

HSV no OpenCV
Um array no sistema HSV pode ser obtido a partir de um array no sistema BGR com
a função cv2.cvtColor(), utilizando o argumento cv.COLOR_BGR2HSV, e vice-versa,
utilizando o argumento cv.COLOR_HSV2BGR
Exemplo
imagemHSV = cv2.cvtColor(imagem, cv2.COLOR_BGR2HSV)
imagemHSV[linha, coluna, :] = (H,S,V)
Exemplo
imagemBGR = cv2.cvtColor(imagem, cv2.COLOR_HSV2BGR)
imagemBGR[linha, coluna, :] = (B,G,R)
Neste caso, o HUE é representado como um valor de 0 a 180

Transformações

Corte
Podemos cortar imagens usando o slice notation do NumPy:
img2 = img[100:500, 100:500, :]
(a) Original (b) Modificada

Redimensionamento
Podemos redimensionar uma imagem usando a função resize do OpenCV.
Esta função recebe dois argumentos:
A imagem original
uma tupla com a altura e a largura da imagem redimensionada
img_resized = cv2.resize(img , (400,400) )
(c) Original (d) Modificada

Efeitos de cores

Imagens monocromáticas
Uma imagem monocromática caracteriza-se por ser completamente composta por
variações de intensidade de uma única cor.
fonte: https://pxhere.com/pt/photo/103348
Uma imagem em tons de cinza é uma imagem monocromática

Imagens monocromáticas
Sistemas fotográficos mais antigos produziam fotografias monocromáticas, as quais
normalmente eram reveladas em tons de cinza. Estas fotografias ganhavam, com o
passar do tempo, uma coloração meio amarelada, chamada "sépia".
fonte: https://pixabay.com/pt/photos/%C3%A1rvores-natureza-s%C3%A9pia-paisagem-584627/
Uma imagem sépia é uma imagem monocromática

Produzindo uma imagem cinza
Podemos obter uma imagem em tons de cinza a partir de uma imagem BGR com o
OpenCV, utilizando a função cvtColor com o argumento COLOR_BGR2GRAY.
cinza = cv2.cvtColor( imagem, cv2.COLOR_BGR2GRAY )
O array obtido possui apenas um canal para cada pixel da imagem.
Um array de apenas um canal para cada pixel da imagem é exibido pela função imshow
como uma imagem cinza

Produzindo uma imagem cinza
Podemos converter a imagem de 1 canal para uma imagem de 3 canais (BGR) uti-
lizando o argumento COLOR_GRAY2BGR.
imagem_bgr = cv2.cvtColor( cinza, cv2.COLOR_GRAY2BGR )
Nos pixels da imagem BGR obtida, os 3 canais têm valores iguais

"Split" de canais da imagem
Podemos separar os 3 canais de uma imagem BGR em 3 arrays.
canal_azul = imagem[ : , : , 0]
canal_verde = imagem[ : , : , 1 ]
canal_vermelho = imagem[ : , : , 2 ]

Modificando cores e intensidades
Para modificar as cores da imagem, podemos aplicar uma função matemática do
NumPy aos canais separados.
Exemplo
def f(x):
return 100 + x/2
vf = np.vectorize(f)
imagem = cv2.imread(’flores.jpg’)
canal_azul = imagem[ : , : , 0 ]
azul_processado = vf(canal_azul)
imagem[ : , : , 0 ] = azul_processado
Neste exemplo, a função f(x) = 100+ x
2
foi aplicada ao canal azul de todos os pixels
da imagem.

A imagem resultante do exemplo anterior foi esta:
(e) Original (f) Modificada
Figure: Primeiro exemplo de imagem modificada

Também podemos modificar cores aplicando produto hadamard nos canais da im-
agem por matrizes de mesma altura e largura que a imagem, preenchidas com valores
de 0 a 1.
Python de Exemplo
b = np.array(imagem[:,:,0], np.float32)
g = np.array(imagem[:,:,1], np.float32)
r = np.array(imagem[:,:,2], np.float32)
b *= mascara
g *= mascara
r *= mascara
imagem[:,:,0] = np.array(b, np.uint8)
imagem[:,:,1] = np.array(g, np.uint8)
imagem[:,:,2] = np.array(r, np.uint8)
Neste exemplo, "mascara" é uma matriz de mesma altura e largura que a imagem,
preenchida com valores de 0 a 1.

(a) Original (b) Modificada (c) Mascara
Figure: Segundo exemplo de imagem modificada

Matriz "mascara" gerada a partir de secante hiperbólica
Código
def criar_mascara(img):
( i , j ) = np.array( np.mgrid[0:img.shape[0], 0:img.shape[1]] , np.float32 )
i /= img.shape[0]
j /= img.shape[1]
f = np.vectorize( lambda x: 1 / ( math.cosh( 2*x - 1 )**4 ) )
return f( i ) * f( j )
mascara = criar_mascara(imagem)
mascara:

Matriz "mascara" gerada a partir de senoide
Código
def criar_mascara( img ):
i /= img.shape[0]
j /= img.shape[1]
f = np.vectorize( lambda x: ( math.sin ( x * math.pi * 3 ) + 1 ) / 2 )
return f( i ) * f( j )
mascara:

Matriz "mascara" linear
Código
def criar_mascara( img ):
i /= img.shape[0]
j /= img.shape[1]
return i * j
mascara:

Podemos criar uma imagem monocromática (não necessariamente em tons de cinza)
a partir de uma imagem colorida da seguinte forma:
1 Carregue a imagem BGR colorida.
2 Transforme a imagem carregada em uma imagem cinza com o comando
cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY).
3 Converta a imagem cinza para uma matriz do tipo float e normalize todos os
valores dividindo-os por 255.
4 Crie uma segunda matriz do tipo float, correspondente a uma imagem de uma
única cor no sistema BGR, com o mesmo tamanho da imagem carregada.
5 Aplique, em cada um dos 3 canais da segunda matriz, um produto hadamard pela
primeira matriz normalizada.
6 Converta esta ultima matriz obtida para uma matriz do tipo uint8. Esta será a
imagem final.

Código
cinza = cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY)
cinza_normalizado = np.array(cinza, np.float32)/255
#Criando matriz de uma cor
sepia = np.ones(imagem.shape)
sepia[:,:,0] *= 153 #B
sepia[:,:,1] *= 204 #G
sepia[:,:,2] *= 255 #R
#Aplicando produto hadamard
sepia[:,:,0] *= cinza_normalizado #B
sepia[:,:,1] *= cinza_normalizado #G
sepia[:,:,2] *= cinza_normalizado #R
imagem_sepia = np.array(sepia, np.uint8)

Figure: Terceiro exemplo de imagem modificada

Histograma e equalização de intensidades

Histogramas de imagem
A distribuição de intensidades em um canal da imagem pode ser representada com
um histograma.
(a) (b)
fonte: https://pt.wikipedia.org/wiki/Equalização_de_histograma

Equalização de histograma
Para melhorar o contraste da imagem, pode ser utilizado um método chamado
equalização de histograma.
Este método distribui uniformemente as intensidades da imagem no histograma.
(c) (d) (e) (f)
fonte: https://pt.wikipedia.org/wiki/Equalização_de_histograma
img_equalizada = cv2.equalizeHist(img)
Obs: A função equalizeHist só funciona com imagens de 1 canal.

Filtros convolucionais

Um filtro convolucional é um método de processamento no qual cada pixel da im-
agem é substituído por um produto interno da sua "região" na imagem por uma matriz
chamada "núcleo" (kernel, em inglês).
Estes filtros podem ser usados para criar efeitos de desfoque, suavização, destacar
bordas, entre outras coisas.
Exemplo
Em uma imagem filtrada com o kernel K, o pixel de coordenadas (5,5) é substituído
pelo produto interno:
Px5,5 = h





Px4,4 Px4,5 Px4,6
Px5,4 Px5,5 Px5,6
Px6,4 Px6,5 Px6,6





,





K0,0 K0,1 K0,2
K1,0 K1,1 K1,2
K2,0 K2,1 K2,2





i (10)
Ou seja:
Px5,5 = (Px4,4 · K0,0) + (Px4,5 · K0,1) + (Px4,6 · K0,2) + (Px5,4 · K1,0) + (Px5,5 · K1,1)+
(Px5,6 · K1,2) + (Px6,4 · K2,0) + (Px6,5 · K2,1) + (Px6,6 · K2,2)
(11)

Esta imagem ilustra o processo:
Fonte: http://www.inf.ufpr.br/aghochuli/caffe/CNN_PPT.pdf

filtros convolucionais: Blur
O "Blur" é um efeito de suavização. Ele faz a imagem parecer desfocada.
Este efeito pode ser produzido substituindo cada pixel da imagem por uma média
ponderada do próprio pixel com seus pixels vizinhos.
(g) Original (h) Modificada
Figure: Exemplo de imagem com Blur
Este processamento pode ser realizado com o uso da função filter2D, do OpenCV.
Neste caso, o kernel deve ser uma matriz cuja soma de todos os valores é igual a
1.

Filtros convolucionais: Blur com média simples
Caso o Kernel seja uma matriz de valores iguais (cujo somatório é 1), a convolução
será uma média aritmética simples.
Kernel =
1
Nlinhas × Ncolunas








1 1 ... 1
1 1 ... 1
.
.
.
.
.
.
...
.
.
.
1 1 ... 1








(12)
Código
import cv2
import numpy as np
kernel = np.ones((100,100))
kernel /= np.sum(kernel)
imagem_blur = cv2.filter2D(imagem, -1, kernel)

Filtros convolucionais: Blur com média simples
O resultado é um efeito de Blur com uma "textura quadriculada".
Figure: Exemplo de imagem com Blur de média simples

Filtros convolucionais: Gaussian Blur
O Desfoque gaussiano (Gaussian Blur), é obtido utilizando um kernel gerado a partir
de uma função gaussiana de duas variáveis.
G(x, y) =
1
2πσ2
e
− x2+y2
2σ2 (13)
Fonte da imagem:
https://pt.stackoverflow.com/questions/252076/problemas-com-aplica%C3%A7%C3%A3o-de-filtro-gaussiano

Exemplo de código para obter o kernel gaussiano 5x5 com σ = 0.5
import numpy as np
import cv2
kernel = np.ones((5,5)) * cv2.getGaussianKernel(5 , 0.5)
kernel *= kernel.T
A função getGaussianKernel(size, sigma) retorna um vetor com os valores da
função gaussiana. O código acima transforma este vetor em uma matriz quadrada.
Kernel ≈










7 · 10−8 3 · 10−5 2 · 10−4 3 · 10−5 7 · 10−8
3 · 10−5 1 · 10−2 8 · 10−2 1 · 10−2 3 · 10−5
2 · 10−4 8 · 10−2 6 · 10−1 8 · 10−2 2 · 10−4
3 · 10−5 1 · 10−2 8 · 10−2 1 · 10−2 3 · 10−5
7 · 10−8 3 · 10−5 2 · 10−4 3 · 10−5 7 · 10−8










(14)
5
X
i=1
5
X
j=1
Kerneli,j = 1 (15)

Exemplo de código para obter o Gaussian Blur com Kernel 100x100 de σ = 10
import numpy as np
import cv2
kernel = np.ones((100,100)) * cv2.getGaussianKernel(100 , 10)
kernel *= kernel.T

Este é o resultado do exemplo:
Figure: Exemplo de imagem com Blur
Perceba que não há mais aquela "textura quadriculada" na imagem processada.
A intensidade do desfoque é proporcional ao tamanho do kernel e ao valor σ (sigma)
da função gaussiana.

filtros convolucionais: Blur diagonal
Quando utilizamos uma matriz diagonal como kernel, obtemos um efeito de desfoque
por movimento.
Figure: Exemplo de imagem com Blur diagonal

Filtros convolucionais: Blur diagonal
O Kernel deve ser uma matriz como esta:
Kernel =
1
Nlinhas








1 0 ... 0
0 1 ... 0
.
.
.
.
.
.
...
.
.
.
0 0 ... 1








(16)
Código do Blur diagonal com Kernel 100x100
import numpy as np
import cv2
kernel = np.eye(100,100)

Filtros convolucionais: Destaque de bordas
O destaque de bordas pode ser obtido pela utilização da função filter2D com um
kernel de valores positivos e negativos cuja soma é 0.
Veja alguns exemplos:
Kernel =


−30 30
30 −30

 (17)

Kernel =





−10 0 0
0 0 0
0 0 10





(18)
(c) Original (d) Modificada

Kernel =





−20 0 20
0 0 0
20 0 −20





(19)
(e) Original (f) Modificada

Kernel =





−3 0 3
−5 0 5
−3 0 3





(20)
(g) Original (h) Modificada

Kernel =





−3 −5 −3
0 0 0
3 5 3





(21)
(i) Original (j) Modificada

Limiarização e Binarização

Limiarização
Limiarizar uma imagem é, básicamente, definir um limiar para os valores de cada
pixel e cada canal da imagem.
Se um valor da imagem for maior, ou menor (dependendo da configuração da limi-
arização), que o limiar, o valor é substituído por uma constante.
(k) Original (l) Limiar 127 para 0

Limiarização
A limiarização pode ser obtida com a função threshold.
ret, imagem2 = cv2.threshold( imagem, limiar, max, modo)
Onde:
imagem : imagem fonte
limiar : valor (número) do limiar
max : valor máximo pelo qual os valores acima do limiar são substituídos (as
vezes esse parâmetro é ignorado)
modo : modo de limiarização escolhido
ignore o ret por enquanto...

Limiarização: THRESH_TOZERO
No modo de limiarização THRESH_TOZERO, os valores abaixo do limiar são substi-
tuídos por 0.
Exemplo
import cv2
img = cv2.imread(’flores.jpg’)
ret, img2 = cv2.threshold( img , 127 , 0 , cv2.THRESH_TOZERO )
O parâmetro max é ignorado neste caso
(m) Original (n) Resultado

Limiarização: THRESH_TRUNC
No modo de limiarização THRESH_TRUNC, os valores acima do limiar são substi-
tuídos pelo próprio valor limiar.
Exemplo
import cv2
ret, img2 = cv2.threshold( img , 50 , 0 , cv2.THRESH_TRUNC )
O parâmetro max é ignorado neste caso
(o) Original (p) Resultado

Limiarização: THRESH_BINARY
No modo de limiarização THRESH_BINARY, os valores acima do limiar são substi-
tuídos pelo valor max, e os valores abaixo do limiar são substituídos por 0.
Exemplo
import cv2
ret, img2 = cv2.threshold( img , 127 , 255 , cv2.THRESH_BINARY )
(q) Original (r) Resultado

Segmentação de bordas

Segmentação de bordas
A segmentação de bordas é um processo que segmenta as regiões de alta variação
de intensidade na imagem.
Figure: Imagem segmentada
Podemos usar a imagem segmentada para detectar bordas

Primeiro passo: Escala de cinza
Primeiro, devemos passar a imagem colorida para escala de cinza
Código
import cv2
import numpy as np
img = cv2.imread(’letras.jpg’)
imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Primeiro passo: Escala de cinza
(a) Original (b) Resultado

Segundo passo: Suavizar
Para reduzir ruídos e pequenos detalhes, precisamos suavizar a imagem. Podemos
usar as funções GaussianBlur( src, (ksizeL, ksizeC) , sigmaX ) ou medianBlur( src,
ksize) .
Código
gblur = cv2.GaussianBlur( imgray , (5,5), 0 )
mblur = cv2.medianBlur( imgray, 5 )

Segundo passo: Suavizar
(c) Original (d) Resultado

Terceiro passo: Binarizar
Para que as bordas fiquem mais evidentes, é necessário binarizar a imagem.
Código
imgbin = cv2.threshold(mblur, 200, 255, cv.THRESH_BINARY)

Terceiro passo: Binarizar
(e) Original (f) Resultado

Terceiro passo: Filtro laplaciano
Para segmentar as bordas da imagem, podemos usar a função Laplacian.
Código
bordas = cv2.Laplacian( mbin , cv2.CV_64F )
O filtro laplaciano é um filtro convolucional que usa o seguinte kernel:
Kernel =





0 −1 0
−1 4 −1
0 −1 0





(22)

Terceiro passo: Filtro laplaciano
(g) Original (h) Resultado

Detecção de contornos
Depois que já obtivemos a imagem segmentada, podemos detectar os contornos da
imagem.
Todos os contornos:
(im, contornos, h) = cv2.findContours( bordas.copy() , cv2.RETR_TREE ,
cv2.CHAIN_APPROX_SIMPLE )
Apenas contornos externos :
(im, contornos, h) = cv2.findContours( bordas.copy() ,
cv2.RETR_EXTERNAL , cv2.CHAIN_APPROX_SIMPLE )
Nestes dois exemplos, a variável contornos recebe uma lista de arrays (do NumPy).
Cada array da lista contêm o conjunto de pontos que formam um dos contornos encon-
trados.

Detecção de bordas
Podemos desenhar os contornos encontrados com a função drawContours:
img2 = cv.drawContours(img, contornos, -1, (0,0,255), 3)
A imagem resultante, na variável img2, é esta:
Figure: Imagem resultante do desenho de contornos

Detecção de objetos

Podemos detectar objetos em imagens usando um CascadeClassifier
Exemplo
import cv2
img = cv2.imread(’turing.jpg’)
classificador = cv2.CascadeClassifier(’frontalface.xml’)
faces = classificador.detectMultiScale( img )
for (x,y,w,h) in faces:
cv2.rectangle(img, (x, y), (x+w, y+h), (0,0,255), 7 )
Neste exemplo, detectamos faces.
O método detectMultiScale, da classe CascadeClassifier, retorna uma matriz do
NumPy na qual cada linha contém, respectivamente, as coordenadas x e y, a largura e
a altura do objeto detectado na imagem.

(a) Original (b) Resultado

Minicurso de processamento de imagem com Python e OpenCV (1ª SECOMP)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Minicurso de processamento de imagem com Python e OpenCV (1ª SECOMP)

Similar to Minicurso de processamento de imagem com Python e OpenCV (1ª SECOMP) (20)

Minicurso de processamento de imagem com Python e OpenCV (1ª SECOMP)