OpenCV é uma biblioteca desenvolvida para projetos de visão computacional. Já tem cerca de 20 anos. Eu a utilizei na faculdade e ainda a aplico em meus projetos em C++ e Python, pois ela possui um bom suporte para essas linguagens.
Mas quando comecei a estudar e usar Go, fiquei curioso para saber se seria possível aplicar o OpenCV com essa linguagem. Na época, já existiam exemplos e tutoriais de integração, mas pareciam um pouco complicados. Um pouco depois, encontrei um wrapper criado pela equipe do The Hybrid Group. Neste artigo, vou mostrar como começar com GoCV, desenvolvendo um simples sistema de reconhecimento facial usando Cascades de Haar.
A Skillbox recomenda: Curso Prático .
Lembramos: para todos os leitores do «Habr» — desconto de 10.000 rublos na inscrição em qualquer curso Skillbox com o código promocional «Habr».
O que será necessário:
- Go;
- OpenCV (links para o instalador abaixo);
- câmera web ou convencional.
Instalação
- Linux:
- macOS:
- Windows:
Exemplo 1
No primeiro exemplo, tentaremos criar um aplicativo que abre uma janela com uma demonstração do fluxo de vídeo da câmera.
Primeiro, precisamos importar as bibliotecas necessárias para o funcionamento.
import (
“log”
“gocv.io/x/gocv”
)
Depois disso, é preciso criar um objeto VideoCapture utilizando a função VideoCaptureDevice. Esta função permite capturar o fluxo de vídeo usando a câmera. Ela utiliza um número inteiro como parâmetro (que representa o ID do dispositivo).
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil { log.Fatalf(“erro ao abrir a webcam: %v”, err)
}
defer webcam.Close()Agora, precisamos criar uma matriz n-dimensional. Ela irá armazenar as imagens lidas da câmera.
img := gocv.NewMat()
defer img.Close()Para exibir o fluxo de vídeo, precisamos criar uma janela — isso pode ser feito com a função NewWindow.
window := gocv.NewWindow(“windowwebcam”)
defer window.Close()Agora, vamos para a parte mais interessante.
Como o vídeo é um fluxo contínuo de frames-imagens, precisaremos criar um loop infinito para continuar lendo o fluxo de vídeo da câmera. Para isso, usaremos o método Read do tipo VideoCapture. Ele aguardará um tipo Mat (a matriz que criamos acima), retornando um valor booleano que indica se o frame foi lido com sucesso ou não.
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println(“Incapaz de ler da webcam”) continue
}
.
.
.
}Agora, precisamos exibir o frame na janela criada. A pausa para passar para o próximo frame será de 50 ms.
window.IMShow(img)
window.WaitKey(50)
Após iniciar o aplicativo, uma janela com o fluxo de vídeo da câmera será aberta.
package main
import (
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("erro ao abrir o dispositivo: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("webcamwindow")
defer window.Close()
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Não foi possível ler da webcam")
continue
}
window.IMShow(img)
window.WaitKey(50)
}
}Exemplo 2
Neste exemplo, vamos aproveitar o exemplo anterior e construir um sistema de reconhecimento facial baseado em Haar Cascades.
Haar Cascades são classificadores em cascata treinados com a técnica de wavelets Haar. Eles analisam os pixels da imagem para detectar características específicas. Para saber mais sobre Haar Cascades, você pode seguir os links abaixo.
Baixar cascades já treinados . No exemplo atual, os cascades serão usados para identificar o rosto de uma pessoa de frente.
Para fazer isso, precisamos criar um classificador e alimentá-lo com um arquivo já treinado (o link está acima). Eu já carreguei o arquivo opencv_haarcascade_frontalface_default.xml no diretório onde nosso programa está localizado.
harrcascade := "opencv_haarcascade_frontalface_default.xml"classifier := gocv.NewCascadeClassifier()classifier.Load(harrcascade)
defer classifier.Close()Para detectar rostos na imagem, precisamos usar o método . Essa função recebe um quadro (tipo Mat) que foi recentemente lido do fluxo de vídeo da câmera e retorna um array do tipo Rectangle. O tamanho do array representa a quantidade de rostos que o classificador conseguiu detectar no quadro. Em seguida, para garantir que estamos vendo o que ele encontrou, vamos percorrer a lista de retângulos e imprimir o objeto Rectangle no console, criando uma borda ao redor do retângulo detectado. Isso pode ser feito com a função Rectangle. Ela receberá Mat, lido pela câmera, o objeto Rectangle que foi retornado pelo método DetectMultiScale, a cor e a espessura para a borda.
for _, r := range rects {
fmt.Println("detectado", r)
gocv.Rectangle(&img, r, color, 2)
} 
package main
import (
"fmt"
"image/color"
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("erro ao abrir a webcam: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("janela da webcam")
defer window.Close()
harrcascade := "opencv_haarcascade_frontalface_default.xml"
classifier := gocv.NewCascadeClassifier()
classifier.Load(harrcascade)
defer classifier.Close()
color := color.RGBA{0, 255, 0, 0}
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Não foi possível ler do dispositivo")
continue
}
rects := classifier.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("detectado", r)
gocv.Rectangle(&img, r, color, 3)
}
window.IMShow(img)
window.WaitKey(50)
}
}E... conseguimos! Agora temos um sistema simples de reconhecimento facial, escrito em Go. Em breve, planejo continuar esses experimentos e criar novas coisas legais, combinando Go e OpenCV.
Se você estiver interessado, avalie , que escrevi em Python e OpenCV. Ele faz streaming de dados no momento da detecção de rosto. Esta é a base para a criação de diferentes clientes em várias linguagens de programação. Eles poderão se conectar ao servidor e ler os dados dele.
Obrigado por ler o artigo!
A Skillbox recomenda:
- Curso Prático de Dois Anos .
- Curso online educacional .
- Curso prático de um ano .
Fonte: habr.com
