Construimos un sistema de reconocimiento facial basado en Golang y OpenCV

OpenCV es una biblioteca diseñada para proyectos de visión por computadora. Tiene alrededor de 20 años. La he usado desde la universidad y todavía la aplico en mis proyectos en C++ y Python, ya que tiene un buen soporte para estos lenguajes.

Pero cuando empecé a estudiar y usar Go, me pregunté si era posible usar OpenCV con este lenguaje. En ese momento ya existían ejemplos y tutoriales sobre la integración, pero me parecieron demasiado complicados. Poco después, encontré un wrapper creado por el equipo de The Hybrid Group. En este artículo, mostraré cómo empezar con GoCV desarrollando un simple sistema de reconocimiento facial con cascadas de Haar.

Skillbox recomienda: Curso práctico «Desarrollador de Python desde cero».

Recordamos: para todos los lectores de «Habr» — un descuento de 10,000 rublos al registrarse en cualquier curso de Skillbox usando el código promocional «Habr».

Qué necesitarás:

• Go;
• OpenCV (enlaces al instalador abajo);
• cámara web o cámara normal.

Instalación

• Linux: gocv.io/getting-started/linux
• macOS: gocv.io/getting-started/macos
• Windows: gocv.io/getting-started/windows

Ejemplo 1

En el primer ejemplo intentaremos crear una aplicación que abra una ventana con una demostración del flujo de video de la cámara.

Primero, hay que importar las bibliotecas necesarias.

import (
"log"
"gocv.io/x/gocv"
)

Después de esto, necesitas crear un objeto VideoCapture usando la función VideoCaptureDevice. Esta última permite capturar el flujo de video desde la cámara. En la función se usa un número entero como parámetro (que representa el ID del dispositivo).

webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {    log.Fatalf("error opening web cam: %v", err)
}
defer webcam.Close()

Ahora necesitas crear una matriz n-dimensional. Esta almacenará las imágenes leídas desde la cámara.

img := gocv.NewMat()
defer img.Close()

Para mostrar el flujo de video, necesitas crear una ventana; esto se puede hacer con la función NewWindow.

window := gocv.NewWindow("webcamwindow")
defer window.Close()

Ahora pasemos a la parte más interesante.

Dado que el video es un flujo continuo de cuadros-imágenes, necesitamos crear un bucle infinito para leer continuamente el flujo de video de la cámara. Para esto se necesita el método Read del tipo VideoCapture. Esto esperará un tipo Mat (la matriz que creamos anteriormente), devolviendo un valor booleano que indica si el cuadro se ha leído correctamente desde VideoCapture o no.

for {     
        if ok := webcam.Read(&img); !ok || img.Empty() {
        log.Println("Unable to read from the webcam")    continue
     }
.
.
.
}

Ahora hay que mostrar el marco en la ventana creada. La pausa para pasar al siguiente marco es de 50 ms.

window.IMShow(img)
window.WaitKey(50)

Después de ejecutar la aplicación, se abrirá una ventana con el flujo de video de la cámara.

paquete principal
 
importar (
"log"
 
"gocv.io/x/gocv"
)
 
func main() {
cámara, err := gocv.VideoCaptureDevice(0)
if err != nil {
    log.Fatalf("error opening device: %v", err)
}
defers cámara.Close()
 
img := gocv.NewMat()
defers img.Close()
 
ventana := gocv.NewWindow("ventanacámara")
defers ventana.Close()
 
for {
if ok := cámara.Read(&img); !ok || img.Empty() {
log.Println("No se puede leer desde la cámara")
continue
}
 
ventana.IMShow(img)
ventana.WaitKey(50)
}
}

Ejemplo 2

En este ejemplo, utilizaremos el ejemplo anterior y construiremos un sistema de reconocimiento facial basado en Haar Cascades (cascadas de Haar).

Las cascadas de Haar son clasificadores en cascada entrenados utilizando la técnica de wavelets de Haar. Analizan los píxeles en la imagen para detectar ciertas características. Para aprender más sobre las Haar Cascades, puedes seguir los enlaces a continuación.

Marco de detección de objetos Viola-Jones
Clasificadores en cascada
Características similares a Haar

Descargar cascadas ya entrenadas puedes hacerlo aquí. En el ejemplo actual, las cascadas se utilizarán para identificar el rostro de una persona de frente.

Para hacer esto, debes crear un clasificador y alimentarle un archivo ya entrenado (el enlace se proporciona arriba). Ya he descargado el archivo opencv_haarcascade_frontalface_default.xml en el directorio donde se encuentra nuestro programa.

harrcascade := “opencv_haarcascade_frontalface_default.xml”clasificador := gocv.NewCascadeClassifier()clasificador.Load(harrcascade)
defers clasificador.Close()

Para detectar rostros en la imagen, debes utilizar el método DetectMultiScale. Esta función toma un fotograma (tipo Mat) que acaba de ser leído del flujo de video de la cámara y devuelve un arreglo de tipo Rectangle. El tamaño del arreglo representa la cantidad de rostros que el clasificador pudo detectar en el fotograma. Luego, para asegurarnos de que vemos lo que encontró, pasemos por la lista de rectángulos y mostremos el objeto Rectangle en la consola, creando un borde alrededor del rectángulo detectado. Esto se puede hacer utilizando la función Rectangle. Tomará Mat, leído por la cámara, el objeto Rectangle devuelto por el método DetectMultiScale, el color y el grosor para el borde.

for _, r := range rects {
fmt.Println(“detected”, r)
gocv.Rectangle(&img, r, color, 2)
}

paquete main
 
importar (
"fmt"
"image/color"
"log"
 
"gocv.io/x/gocv"
)
 
func main() {
cámara, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("error abriendo la cámara web: %v", err)
}
defer cámara.Close()
 
img := gocv.NewMat()
defer img.Close()
 
ventana := gocv.NewWindow("ventanacámara")
defer ventana.Close()
 
harrcascade := "opencv_haarcascade_frontalface_default.xml"
clasificador := gocv.NewCascadeClassifier()
clasificador.Load(harrcascade)
defer clasificador.Close()
 
color := color.RGBA{0, 255, 0, 0}
for {
if ok := cámara.Read(&img); !ok || img.Empty() {
log.Println("No se pudo leer del dispositivo")
continue
}
 
rects := clasificador.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("detectado", r)
gocv.Rectangle(&img, r, color, 3)
}
 
vientana.IMShow(img)
vientana.WaitKey(50)
}
}

¡Y… sí, todo ha funcionado! Ahora tenemos un sistema simple de reconocimiento facial, escrito en Go. Pronto planeo continuar estos experimentos y crear cosas nuevas e interesantes, combinando Go y OpenCV.

Si te interesa, evalúa servidor web gRPC, que escribí en Python y OpenCV. Transmite datos en el momento en que se detecta un rostro. Esta es la base para crear diferentes clientes en diferentes lenguajes de programación. Podrán conectarse al servidor y leer datos de él.

¡Gracias por leer el artículo!

Skillbox recomienda:

• Curso práctico de dos años «Soy Desarrollador Web PRO».
• Curso en línea educativo «Profesión Desarrollador Java».
• Curso práctico de un año «Desarrollador PHP desde 0 hasta PRO».

Fuente: habr.com