O pipeline de Visão Computacional
Entenda de uma vez por todas, como os sistemas de Visão Computacional funcionam por trás dos panos, com códigos, exemplos e tudo mais! :)
O pipeline de Visão Computacional
O chamado pipeline de sistemas de Visão Computacional, são todas as etapas detalhadas que um sistema passa para conseguir que o computador receba uma imagem e associe um nome ou significado a ela. A maior parte dos sistemas baseados em Visão Computacional passam pelas etapas de: aquisição de imagem, pré-processamento de imagem, extração de características e detecção de padrões, vamos entender cada uma das etapas com profundidade.
Etapa 1: Aquisição da Imagem
A primeira etapa consiste em enviar uma imagem para o seu sistema, para tanto, podemos enviar uma imagem, ou exibir um vídeo em tempo real ( já que um vídeo, nada mais é, que uma sequência de imagens que estão sendo exibidas muito rápido).
Lendo Imagens:
import cv2
import numpy as npimage = cv2.imread(“todo/o/caminho/do/diretorio/da/imagem.jpg”)
cv2.imshow(“Nome que voce quiser dar para a janela”, image)
cv2.waitKey(0)
Lendo vídeos em tempo real:
import cv2
import numpy as np#Abre a captura de video da camera
video_capture = cv2.VideoCapture(0)#Enquanto a captura de video estiver aberta
while video_capture.isOpened(): #Le a captura de video e guarda a imagem na variável frame
ret, frame = video_capture.read()#Mostra a imagem que está sendo guardada na variavel frame em tempo #real
cv2.imshow("image", frame)
cv2.waitKey(0)
Etapa 2: Pré-processamento
As etapas de pré-processamento, são operações realizadas para realçar objetos, remover ruído da imagem, normalizar a imagem tornando as partes escuras mais claras e as partes muito claras mais escuras e são utilizadas conforme a necessidade do problema que o sistema de Visão Computacional se propõe a resolver. Estas etapas podem englobar:
1. Filtros na imagem:
São readequações que podem ser feitas principalmente alterando os níveis de intensidade de cores, luminosidade, quantidade de canais de cores.
Escala de Cinza:
Um tipo de filtro de imagem, a escala de cinza é considerada uma técnica clássica, geralmente utilizada para diminuir o tamanho da complexidade a ser processada, já que a maioria das imagens possuem 3 canais de cores (em geral RGB). Ao colocar a imagem em escala de cinza, diminuímos a complexidade do problema, já que teremos apenas um canal com intensidade de cores variando de 0 a 255, em vez dos 3 canais.
import cv2
import numpy as npimage = cv2.imread("todo/o/caminho/do/diretorio/da/imagem.jpg")
gray = cv2.cvtcolor(image, cv2.COLOR_BGR2GRAY)cv2.imshow("Nome que voce quiser dar para a janela", image)
cv2.waitKey(0)
Equalização de Histograma:
Este filtro é capaz de equalizar a intensidade dos pixels ao longo da imagem, ou seja, se a imagem estiver muito clara, ela é escurecida e se tiver muito escura, a imagem será clareada.
import cv2
import numpy as np
img = cv2.imread('imagem_exemplo.jpg',0)
equ = cv2.equalizeHist(img)
res = np.hstack((img,equ))
cv2.imshow('Equalizacao de Histograma',res)
cv2.waitKey(0)
2. Transformações Geométricas:
Algumas transformações geométricas podem ser aplicadas na imagem. As mais utilizadas são:
Rotação:
A rotação é um pré-processamento importante em alguns sistemas de visão computacional, em sistemas de detecção facial, por exemplo, são muito utilizados.
import cv2
import numpy as nprotation = 90
imagemOriginal = cv2.imread("folha.jpeg", 0)
totalLinhas, totalColunas = imagemOriginal.shape
matriz = cv2.getRotationMatrix2D(
(totalColunas / 2, totalLinhas / 2), rotation, 1
)
imagemRotacionada = cv2.warpAffine(
imagemOriginal,
matriz,
(totalColunas, totalLinhas)
)
cv2.imshow("Resultado", imagemRotacionada)
cv2.waitKey(0)
Crop:
O crop é utilizado para definir alguma região de interesse, em torno da imagem ou padrão que deseja ser encontrado, é muito utilizado para melhorar performance e tempo de processamento em sistemas de visão computacional.
import cv2
import numpy as npimg=cv2.imread("imagem.jpg",0)y=0
x=0
height = img.shape[0]
width = img.shape[1]crop = img[y:y+(height), x:x+(width/2)]
cv2.imshow("cropped", crop)
cv2.waitKey(0)
Etapa 3: Extração de Características
A fase de extração de características de um objeto é um procedimento fundamental, presente na maior parte de qualquer sistema de Visão Computacional. Ela consiste em obter informações que tornam possível classificar ou identificar um objeto.
As características de um objeto podem ser classificadas em categorias, sendo as principais: como características de cor, de aspecto, de forma, entre outras.
Extração de cor:
Entre as características que podem ser extraídas de um objeto, a cor é uma das mais importantes, tanto para a visão humana quanto para os sistemas baseados em Visão Computacional. Muitas vezes, somos capazes de identificar um objeto apenas por sua cor, e o mesmo é válido para os sistemas de Visão Computacional.
No exemplo abaixo, criamos uma “capa de invisibilidade”, que transforma todos os pixeis brancos em preto.
import cv2
import numpy as npvideo_capture = cv2.VideoCapture(0)while (True):
ret, frame = video_capture.read()
hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#Mostra todas as cores, menos o branco
low = np.array([0, 65, 0])
high = np.array([255, 255, 255])
mask = cv2.inRange(hsv_frame, low, high)
#Aplica a mascara
result = cv2.bitwise_and(frame, frame, mask=mask)
#Exibe o frame
cv2.imshow("Frame", frame)
cv2.imshow("Result", result)#Sair do programa
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
Extração de linhas:
Padrões de formatos, linhas contornos e vértices, podem ser úteis para determinar a área e posicionamento de objetos a serem detectados. Abaixo, um exemplo de extração de linhas em um gráfico.
import numpy as np
import cv2img = cv2.imread('faturamento.png')# hsv value including border and back ground
hsv_min = (0, 0, 0) # Lower end of the HSV range
hsv_max = (10, 10, 255) # Upper end of the HSV range# Transform image to HSV color space
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)# Threshold based on HSV values
color_thresh = cv2.inRange(hsv, hsv_min, hsv_max)# Invert the image
invert = cv2.bitwise_not(color_thresh)cv2.imshow("lines.png", invert)
cv2.waitKey(0)
Etapa 4: Detecção de Padrões
A habilidade que todo ser humano possui de reconhecer padrões e classificar objetos sempre impressionou cientistas dos mais diversificados campos de estudo, principalmente os que se dedicam a desenvolver tecnologias capazes de imitar a natureza humana.
A detecção de padrões é uma área que estuda técnicas para entender padrões de objetos a fim de classificá-los. Nos sistemas baseados em Visão Computacional, as técnicas de reconhecimento de padrões são essenciais, pois possibilitam a classificação automática de um objeto de interesse.
Na prática, essa etapa do pipeline que efetivamente faz que computadores enxerguem o mundo à nossa volta, reconhecendo placas, peças, caracteres, faces humanas e outros objetos. Tanto para as máquinas como para nós, humanos, o reconhecimento de objetos é proporcionado por suas características particulares. Existem várias técnicas capazes de ensinar computadores a detectar padrões em imagem, vamos abordar as principais delas.
Detector de Faces
Elaborado por Paul Viola e Michael Jones em 2001, o Haar Cascade é um excelente algoritmo de busca de padrões em imagens. Denominado originalmente como algoritmo de Viola-Jones, ele utiliza uma abordagem baseada em aprendizado de máquina, no qual são usadas imagens positivas e negativas para o treinamento. Imagens positivas são imagens que contêm o objeto de interesse representado; do contrário, as negativas são as que não contêm o objeto representado.
Uma série de padrões de regiões mais claras e escuras, como os exemplos abaixo, são buscadas na imagem. A partir dai, se for encontrado na imagem uma quantidade suficiente dos padrões esperadas, a face é detectada.
O exemplo abaixo, indica um detector de faces e sorrisos. Todas as regras dos classificadores estão armazenadas no arquivos XML, de classificação, que podem ser baixados no Projeto disponível no GitHub.
import cv2
import numpy as np#Setando o XML de classificacao
def set_classifier(cascPath):
cascPath = cascPath
faceCascade = cv2.CascadeClassifier(cascPath)
return faceCascadedef detectSmile(img,faces):
for (x, y, w, h) in faces:
smileCascade = set_classifier('classifiers/haarcascade_smile.xml')
roi_smile = img[y:y+h, x:x+w]
smile = smileCascade.detectMultiScale(
roi_smile,
scaleFactor=1.1,
minNeighbors=70,
minSize=(15, 15)
)
#Create the Smile Rectangle
for (sp, sq, sr, ss) in smile:
cv2.rectangle(roi_smile,(sp,sq),(sp+sr,sq+ss), (0,0,255),3)
return True
return False
def put_msg(msg,frame,px,py):
font = cv2.FONT_HERSHEY_SIMPLEX
color = (0,0,255)
cv2.putText(frame,msg,(px,py), font, 1.5,(0,0,0),3)#Comeca a pegar a imagem da WebCam
video_capture = cv2.VideoCapture(0)while True:
#Etapa: Aquisicao da imagem
#Captura e faz a leitura de cada frame em tempo real
ret, frame = video_capture.read()#Etapa: Pre-processamento
#Espelha a imagem
frame = cv2.flip(frame,180)
#Filtra a imagem em escala de cinza
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)#Etapa: Deteccao do rosto
#Seta o classificador do rosto
faceCascade = set_classifier('classifiers/haarcascade_frontalface_default.xml')#Seta as configuracoes do classificador do ROSTO
faces = faceCascade.detectMultiScale(
frame,
scaleFactor=1.1,
minNeighbors=8,
minSize=(120, 120)
)#Desenha um retangulo no rosto encontrado
for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 3)
#Etapa: Deteccao do sorriso
#Detecta sorriso
smile = detectSmile(frame,faces)
#Se o sorriso for detectado
if(smile):
put_msg("Smile detected",frame,50,50)#Exibe o frame da imagem
cv2.imshow('Video', frame)#Sair do programa
if cv2.waitKey(1) & 0xFF == ord('q'):
breakvideo_capture.release()
cv2.destroyAllWindows()
