OpenCV est une bibliothèque développée pour des projets de vision par ordinateur. Elle existe depuis environ 20 ans. Je l'ai utilisée encore à l'université et je l'applique toujours pour mes projets en C++ et Python, car elle dispose d'un bon support pour ces langages.
Mais quand j'ai commencé à étudier et à utiliser Go, je me suis demandé s'il était possible d'appliquer OpenCV avec ce langage. À l'époque, il existait déjà des exemples et des tutoriels d'intégration, mais j'ai trouvé qu'ils étaient trop compliqués. Peu après, j'ai trouvé un wrapper créé par l'équipe de The Hybrid Group. Dans cet article, je vais montrer comment commencer avec GoCV en développant un simple système de reconnaissance faciale utilisant des cascades de Haar.
Skillbox recommande : Cours pratique .
Rappelons-le : pour tous les lecteurs de « Habr » — une réduction de 10 000 roubles lors de l'inscription à tout cours Skillbox avec le code promo « Habr ».
Ce qu'il faut :
- Go;
- OpenCV (liens vers l'installateur ci-dessous);
- une caméra vidéo ou ordinaire.
Installation
- Linux :
- macOS :
- Windows :
Exemple 1
Dans le premier exemple, nous allons essayer de créer une application qui ouvre une fenêtre avec une démonstration du flux vidéo de la caméra.
Tout d'abord, nous devons importer les bibliothèques nécessaires au travail.
import (
"log"
"gocv.io/x/gocv"
)
Ensuite, nous devons créer un objet VideoCapture en utilisant la fonction VideoCaptureDevice. Cette dernière permet de capturer le flux vidéo à l'aide de la caméra. La fonction utilise un entier comme paramètre (qui représente l'ID de l'appareil).
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil { log.Fatalf("erreur lors de l'ouverture de la webcam : %v", err)
}
defer webcam.Close()Nous devons maintenant créer une matrice n-dimensionnelle. Elle va stocker les images capturées par la caméra.
img := gocv.NewMat()
defer img.Close()Pour afficher le flux vidéo, nous devons créer une fenêtre - cela peut être fait en utilisant la fonction NewWindow.
window := gocv.NewWindow("webcamwindow")
defer window.Close()Passons maintenant à la partie la plus intéressante.
Comme la vidéo est un flux continu de cadres-image, nous devrons créer une boucle infinie pour lire en continu le flux vidéo de la caméra. Pour cela, nous avons besoin de la méthode Read de type VideoCapture. Elle attendra un type Mat (la matrice que nous avons créée ci-dessus), en retournant une valeur booléenne indiquant si le cadre a été lu avec succès depuis VideoCapture ou non.
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Impossible de lire depuis la webcam") continue
}
.
.
.
}Nous devons maintenant afficher le cadre dans la fenêtre créée. La pause pour passer au cadre suivant est de 50 ms.
window.IMShow(img)
window.WaitKey(50)
Après le lancement de l'application, une fenêtre s'ouvrira avec le flux vidéo de la caméra.
package main
import (
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("error opening device: %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("Unable to read from the webcam")
continue
}
window.IMShow(img)
window.WaitKey(50)
}
}Exemple 2
Dans cet exemple, utilisons l'exemple précédent et construisons un système de reconnaissance faciale basé sur les Haar Cascades.
Les Haar Cascades sont des classificateurs en cascade qui sont entraînés à l'aide de la technique des ondelettes de Haar. Ils analysent les pixels d'une image pour détecter certaines caractéristiques. Pour en savoir plus sur les Haar Cascades, vous pouvez consulter les liens ci-dessous.
Télécharger des cascades pré-entraînées . Dans cet exemple, les cascades seront utilisées pour identifier le visage d'une personne de face.
Pour ce faire, il faut créer un classificateur et lui fournir un fichier déjà entraîné (le lien est donné ci-dessus). J'ai déjà téléchargé le fichier opencv_haarcascade_frontalface_default.xml dans le répertoire où se trouve notre programme.
harrcascade := "opencv_haarcascade_frontalface_default.xml"classificador := gocv.NewCascadeClassifier()classificador.Load(harrcascade)
defer classificador.Close()Pour détecter des visages dans l'image, il faut utiliser la méthode . Cette fonction prend une image (type Mat) qui a été récemment lue à partir du flux vidéo de la caméra et retourne un tableau de type Rectangle. La taille du tableau représente le nombre de visages que le classificateur a réussi à détecter dans l'image. Ensuite, pour s'assurer que nous voyons ce qu'il a trouvé, parcourons la liste des rectangles et affichons l'objet Rectangle dans la console, en créant une bordure autour du rectangle détecté. Cela peut être fait à l'aide de la fonction Rectangle. Elle prendra Mat, lue par la caméra, l'objet Rectangle retourné par la méthode DetectMultiScale, la couleur et l'épaisseur pour la bordure.
for _, r := range rects {
fmt.Println("detected", 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("error opening web cam: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("webcamwindow")
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("Unable to read from the device")
continue
}
rects := classifier.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("detected", r)
gocv.Rectangle(&img, r, color, 3)
}
window.IMShow(img)
window.WaitKey(50)
}
}Et… oui, tout a fonctionné ! Nous avons maintenant un système de reconnaissance faciale simple, écrit en Go. Je prévois bientôt de continuer ces expériences et de créer de nouvelles choses intéressantes en combinant Go et OpenCV.
Si cela vous intéresse, n'hésitez pas à évaluer , que j'ai écrit en Python et OpenCV. Il diffuse des données en temps réel lors de la détection d'un visage. C'est la base pour créer différents clients dans divers langages de programmation. Ils pourront se connecter au serveur et lire les données.
Merci d'avoir lu l'article !
Skillbox recommande :
- Cours pratique de deux ans .
- Cours en ligne éducatif .
- Cours pratique d'un an .
Source : habr.com
