Reconnaissance de plaque d'immatriculation avec Raspberry Pi et OPENCV

La sécurité a toujours été une préoccupation majeure pour l'humanité. Aujourd'hui, nous avons des caméras de vidéosurveillance dans les écoles, les hôpitaux et tous les autres lieux publics pour nous faire sentir en sécurité. Selon une enquête menée par HIS, on estime qu'en 2014, environ 245 millions de caméras de sécurité ont été installées et fonctionnelles, ce qui revient à avoir une caméra de sécurité pour 30 personnes sur cette planète. Avec les progrès de la technologie, en particulier dans le traitement d'image et l'apprentissage automatique, il est possible de rendre ces caméras plus intelligentes en les entraînant à traiter les informations du flux vidéo.

Le flux vidéo de ces caméras peut être utilisé pour effectuer la reconnaissance faciale, l'analyse des modèles, l'analyse des émotions et bien plus encore, ce qui le rapprocherait vraiment de quelque chose comme «l'œil de Dieu» montré dans le film FF7. En fait, des sociétés de surveillance comme Hikvision et bien d'autres ont déjà commencé à implémenter ces fonctionnalités dans leurs produits. Nous utilisions auparavant le traitement d'image MATLAB pour lire la plaque d'immatriculation, aujourd'hui, dans cet article, nous allons apprendre à reconnaître et à lire le numéro de plaque d' immatriculation des automobiles à l'aide de Raspberry Pi et OpenCV. Nous utiliserons des images aléatoires de véhicules de Google et écrirons un programme pour reconnaître la plaque d'immatriculation à l'aide d'OpenCV Contour Detection, puis lirons le numéro de la plaque à l'aide de Tesseract OCR. Cela semble intéressant à droite !, alors commençons.

Conditions préalables

Comme indiqué précédemment, nous utiliserons la bibliothèque OpenCV pour détecter et reconnaître les visages. Assurez-vous donc d'installer OpenCV Library sur Raspberry Pi avant de poursuivre ce tutoriel. Alimentez également votre Pi avec un adaptateur 2A et connectez-le à un moniteur d'affichage pour un débogage plus facile.

Ce didacticiel n'expliquera pas comment fonctionne exactement OpenCV.Si vous souhaitez apprendre le traitement d'image, consultez ces principes de base d'OpenCV et les didacticiels avancés sur le traitement d'image. Vous pouvez également en apprendre davantage sur les contours, la détection de blob, etc. dans ce didacticiel de segmentation d'image à l'aide d'OpenCV. Nous allons faire quelque chose de similaire pour détecter la plaque d'immatriculation de la voiture à partir de l'image.

Étapes impliquées dans la reconnaissance des plaques d'immatriculation à l'aide de Raspberry Pi

La reconnaissance de plaque d'immatriculation ou LPR en abrégé, implique trois étapes principales. Les étapes sont les suivantes

1. Détection de plaque d'immatriculation: La première étape consiste à détecter la plaque d'immatriculation de la voiture. Nous utiliserons l'option de contour d'OpenCV pour détecter les objets rectangulaires afin de trouver la plaque d'immatriculation. La précision peut être améliorée si nous connaissons la taille exacte, la couleur et l'emplacement approximatif de la plaque d'immatriculation. Normalement, l'algorithme de détection est formé en fonction de la position de la caméra et du type de plaque d'immatriculation utilisé dans ce pays particulier. Cela devient plus délicat si l'image n'a même pas de voiture, dans ce cas, nous allons faire une étape supplémentaire pour détecter la voiture puis la plaque d'immatriculation.

2. Segmentation des caractères: Une fois que nous avons détecté la plaque d'immatriculation, nous devons la rogner et l'enregistrer sous une nouvelle image. Encore une fois, cela peut être fait facilement en utilisant OpenCV.

3. Reconnaissance de caractères: Maintenant, la nouvelle image que nous avons obtenue à l'étape précédente est sûre d'avoir des caractères (nombres / alphabets) écrits dessus. Ainsi, nous pouvons effectuer l'OCR (Optical Character Recognition) dessus pour détecter le nombre. Nous avons déjà expliqué la reconnaissance optique de caractères (OCR) à l'aide de Raspberry Pi.

1. Détection de plaque d'immatriculation

La première étape de ce lecteur de plaque d'immatriculation Raspberry Pi consiste à détecter la plaque d'immatriculation. Prenons un exemple d'image d'une voiture et commençons par détecter la plaque d'immatriculation sur cette voiture. Nous utiliserons ensuite la même image pour la segmentation et la reconnaissance de caractères. Si vous voulez entrer directement dans le code sans explication, vous pouvez faire défiler vers le bas de cette page, où le code complet est fourni. L'image de test que j'utilise pour ce didacticiel est illustrée ci-dessous.

Étape 1: Redimensionnez l'image à la taille requise, puis mettez-la en niveaux de gris. Le code pour le même est donné ci-dessous

img = cv2.resize (img, (620,480)) gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) # convertir en échelle de gris

Redimensionnement nous nous aidons à éviter tout problème avec des images de plus grande résolution, assurez-vous que la plaque d'immatriculation reste toujours dans le cadre après le redimensionnement. La mise à l'échelle des gris est commune à toutes les étapes de traitement d'image. Cela accélère les autres processus suivants, car nous n'avons plus à gérer les détails de couleur lors du traitement d'une image. L'image serait transformée quelque chose comme ça lorsque cette étape est terminée

Étape 2: Chaque image contiendra des informations utiles et inutiles, dans ce cas, pour nous, seule la plaque d'immatriculation est l'information utile, le reste est pratiquement inutile pour notre programme. Cette information inutile s'appelle le bruit. Normalement, l' utilisation d'un filtre bilatéral (Bluring) supprimera les détails indésirables d'une image. Le code pour le même est

gray = cv2.bilateralFilter (gris, 11, 17, 17)

La syntaxe est destination_image = cv2.bilateralFilter (image_source, diamètre du pixel, sigmaColor, sigmaSpace). Vous pouvez augmenter la couleur sigma et l'espace sigma de 17 à des valeurs plus élevées pour brouiller plus d'informations d'arrière-plan, mais veillez à ce que la partie utile ne soit pas floue. L'image de sortie est montrée ci-dessous, comme vous pouvez voir les détails d'arrière-plan (arbre et bâtiment) sont flous dans cette image. De cette façon, nous pouvons éviter que le programme ne se concentre plus tard sur ces régions.

Étape 3: La prochaine étape est intéressante où nous effectuons la détection des bords. Il existe de nombreuses façons de le faire, le moyen le plus simple et le plus populaire est d'utiliser la méthode astucieuse d'OpenCV. La ligne pour faire de même est indiquée ci-dessous

edged = cv2.Canny (gray, 30, 200) #Perform Edge détection

La syntaxe sera destination_image = cv2.Canny (source_image, thresholdValue 1, thresholdValue 2). La valeur de seuil 1 et la valeur de seuil 2 sont les valeurs de seuil minimum et maximum. Seuls les bords dont le gradient d'intensité est supérieur à la valeur de seuil minimum et inférieur à la valeur de seuil maximum seront affichés. L'image résultante est affichée ci-dessous

Étape 4: Nous pouvons maintenant commencer à rechercher des contours sur notre image, nous avons déjà appris comment trouver des contours à l'aide d'OpenCV dans notre tutoriel précédent, nous procédons donc de la même manière.

nts = cv2.findContours (edged.copy (), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours (cnts) cnts = sorted (cnts, key = cv2.contourArea, reverse = True) screenCnt = None

Une fois les compteurs détectés, nous les trions du plus grand au plus petit et ne considérons que les 10 premiers résultats en ignorant les autres. Dans notre image, le compteur pourrait être tout ce qui a une surface fermée, mais de tous les résultats obtenus, le numéro de plaque d'immatriculation sera également là puisqu'il s'agit également d'une surface fermée.

Pour filtrer l'image de la plaque d'immatriculation parmi les résultats obtenus, nous allons parcourir tous les résultats et vérifier lequel a un contour en forme de rectangle à quatre côtés et une figure fermée. Puisqu'une plaque d'immatriculation serait certainement un rectangle à quatre faces.

# boucle sur nos contours pour c en cnts: # approximer le contour peri = cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, 0.018 * peri, True) # si notre contour approximé a quatre points, alors # nous peut supposer que nous avons trouvé notre écran si len (approx) == 4: screenCnt = approx break

La valeur 0,018 est une valeur expérimentale; vous pouvez jouer autour pour vérifier ce qui vous convient le mieux. Ou passez au niveau supérieur en utilisant l'apprentissage automatique pour vous entraîner à partir d'images de voiture, puis utilisez la bonne valeur là-bas. Une fois que nous avons trouvé le bon compteur, nous l'enregistrons dans une variable appelée screenCnt , puis dessinons un rectangle autour de lui pour nous assurer que nous avons détecté correctement la plaque d'immatriculation.

Étape 5: Maintenant que nous savons où se trouve la plaque d'immatriculation, les informations restantes nous sont pratiquement inutiles. Nous pouvons donc procéder au masquage de l'image entière sauf pour l'endroit où se trouve la plaque d'immatriculation. Le code pour faire de même est indiqué ci-dessous

# Masquage de la partie autre que la plaque d'immatriculation mask = np.zeros (gray.shape, np.uint8) new_image = cv2.drawContours (mask,, 0,255, -1,) new_image = cv2.bitwise_and (img, img, mask = masque)

La nouvelle image masquée apparaîtra comme ci-dessous

2. Segmentation des caractères

La prochaine étape de la reconnaissance de plaque d'immatriculation Raspberry Pi consiste à segmenter la plaque d'immatriculation hors de l'image en la recadrant et en l'enregistrant en tant que nouvelle image. Nous pouvons ensuite utiliser cette image pour détecter le personnage qu'elle contient. Le code pour recadrer l'image ROI (Région d'intérêt) de l'image principale est indiqué ci-dessous

# Maintenant crop (x, y) = np.where (mask == 255) (topx, topy) = (np.min (x), np.min (y)) (bottomx, bottomy) = (np.max (x), np.max (y)) Recadrée = gris

L'image résultante est présentée ci-dessous. Normalement ajouté au recadrage de l'image, nous pouvons également la griser et la border si nécessaire. Ceci est fait pour améliorer la reconnaissance des caractères à l'étape suivante. Cependant, j'ai trouvé que cela fonctionne bien même avec l'image d'origine.

3. Reconnaissance des caractères

La dernière étape de cette reconnaissance de plaque d'immatriculation Raspberry Pi consiste à lire les informations de plaque d'immatriculation à partir de l'image segmentée. Nous utiliserons le package pytesseract pour lire les caractères de l'image, comme nous l'avons fait dans le didacticiel précédent. Le code pour le même est donné ci-dessous

#Lire la plaque d'immatriculation text = pytesseract.image_to_string (Cropped, config = '- psm 11') print ("Le numéro détecté est:", texte)

Nous avons déjà expliqué comment configurer un moteur Tesseract, donc ici encore si nécessaire, nous pouvons configurer l'OCR Tesseract pour obtenir de meilleurs résultats si nécessaire. Le caractère détecté est ensuite imprimé sur la console. Une fois compilé, le résultat est affiché comme ci-dessous

Comme vous pouvez le voir, l'image originale portait le numéro «HR 25 BR9044» et notre programme a détecté qu'elle a imprimé la même valeur à l'écran.

Cas d'échec dans la reconnaissance de plaque d'immatriculation

Le fichier de projet complet de cette reconnaissance de plaque d'immatriculation Raspberry Pi peut être téléchargé à partir d'ici, il contient le programme et les images de test que nous avons utilisées pour vérifier notre programme. Sans être dit, il faut se rappeler que les résultats de cette méthode ne seront pas précis . La précision dépend de la clarté de l' image, l' orientation, exposition à la lumière, etc. Pour obtenir de meilleurs résultats, vous pouvez essayer d'implémenter des algorithmes d'apprentissage automatique avec cela.

Pour avoir une idée, regardons un autre exemple où la voiture n'est pas directement face à la caméra.

Comme vous pouvez le voir, notre programme a pu détecter correctement la plaque d'immatriculation et la recadrer. Mais la bibliothèque Tesseract n'a pas réussi à reconnaître correctement les personnages. Au lieu du véritable «TS 08 UE 3396», l'OCR l'a reconnu comme étant «1508 ye 3396». Des problèmes comme celui-ci peuvent être corrigés soit en utilisant de meilleures images d'orientation, soit en configurant le moteur Tesseract .

Un autre pire scénario est celui où le contour ne détecte pas correctement la plaque d'immatriculation. L'image ci-dessous contient trop d'informations de fond et un mauvais éclairage que le programme n'a même pas réussi à identifier la plaque d'immatriculation à partir du numéro. Dans ce cas, nous devons à nouveau relayer l'apprentissage automatique ou améliorer la qualité de l'image.

Autres exemples réussis

La plupart du temps, la qualité de l'image et l'orientation sont correctes, le programme a pu identifier la plaque d'immatriculation et en lire le numéro. Les instantanés ci-dessous montrent quelques-uns des résultats positifs obtenus. Encore une fois, toutes les images de test et le code utilisé ici seront disponibles dans le fichier ZIP fourni ici.

J'espère que vous avez compris la reconnaissance automatique des plaques d'immatriculation à l'aide de Raspberry Pi et que vous avez aimé construire quelque chose de cool par vous-même. Que pensez-vous pouvoir faire d'autre avec OpenCV et Tesseract ?, Faites-moi part de vos commentaires dans la section commentaires. Si vous avez des questions concernant cet article, n'hésitez pas à les laisser dans la section commentaires ci-dessous ou à utiliser les forums pour d'autres questions techniques.