System do rozpoznawania tablic rejestracyjnych

Piątek, 01 Październik 2021

Rozpoznawanie napisów nie jest nową technologią. Pierwsze rozwiązania powstały już w latach ’80 XX wieku i były stosowane przede wszystkim do digitalizacji książek i dokumentów. Wraz z upowszechnieniem się wydajnych platform obliczeniowych, technologia ta trafiła również do systemów wbudowanych takich, jak kamery na parkingach, które identyfikują samochody na podstawie tablic rejestracyjnych.

Rozpoznawanie tablic rejestracyjnych pojazdów nie jest funkcjonalnością łatwą do zrealizowania, ale bardzo potrzebną m.in. w systemach parkingowych czy nadzorujących ruch. Umożliwia automatyzację procesu poboru opłat parkingowych czy też identyfikację pojazdów przejeżdżających na czerwonym świetle lub łamiących inne przepisy ruchu drogowego. Zaprezentowany projekt bazuje na komputerze jednopłytkowym Raspberry Pi i korzysta z algorytmów przetwarzania obrazu do automatycznego rozpoznawania tablic rejestracyjnych pojazdów. System zawiera kamerę Full HD z czujnikiem podczerwieni oraz prosty wyświetlacz LCD. Stale przetwarza obraz z kamery i wykrywa pojawienie się tablicy rejestracyjnej pojazdu. Po jej wykryciu, algorytm przetwarza dane z kamery, wyodrębnia obraz tablicy rejestracyjnej z całego obrazu i przetwarza go za pomocą algorytmu OCR. Finalnie uzyskiwany jest numer rejestracyjny, który zostaje wyświetlony na klasycznym wyświetlaczu LCD 2×16.

System taki może mieć wiele zastosowań – zamiast tylko wyświetlić odczytany z tablicy tekst na ekranie LCD, można zapisać go w bazie danych, lub, na przykład podnieść szlaban wjazdu na parking, jeśli tablica jest właściwa.

Potrzebne elementy

Zbudowanie zaprezentowanego systemu wymaga kilku komponentów. Potrzebne są:

komputer jednopłytkowy Raspberry Pi 3,
wyświetlacz LCD z kontrolerem HD44780,
buzzer,
oporniki, kondensatory i tranzystory, potrzebne do konstrukcji płytki bazowej,
diody LED,
kable i złącza, do integracji wszystkich systemów.
zasilacz DC,
kamera USB z sensorem Full HD i możliwością obserwacji w podczerwieni.

Dodatkowo konieczne jest oprogramowanie, które trzeba zainstalować na Raspberry Pi. Aby zaprezentowany dalej skrypt działał poprawnie, musimy zainstalować w systemie następujące komponenty:

system operacyjny Linux,
interpreter Pythona, jeśli nie jest domyślnie obecny w systemie,
biblioteka Adafruit_CharLCD do obsługi wyświetlacza LCD,
biblioteka OpenCV.

Przygotowanie sprzętu

Przygotowując Raspberry Pi należy upewnić się, że maszyna posiada wolne trzy wejścia USB, wyjście HDMI i oczywiście gniazdo kart micro SD. Do USB podłączone będą: kamera, mysz i klawiatura. Czwarte wejście przydatne będzie do podłączenia np. dysku USB lub na przykład układów wykonawczych, jeśli komputer ma czymś sterować. Do złącza HDMI można dołączyć monitor i obserwować działanie systemu, do gniazda kart Micro SD należy zainstalować kartę pamięci z zapisanym systemem operacyjnym.

Fotografia 1. Płytka drukowana umożliwiająca połączenie wszystkich elementów systemu

Płytka główna urządzenia zawiera blok zasilania oraz kilka elementów dodatkowych (fotografia 1), w tym przycisk resetowania. Odpowiednie złącza, umożliwiają łatwe połączenie komputerka z wyświetlaczem. Alfanumeryczny wyświetlacz LCD 16×2 podłączony jest do Raspberry Pi w trybie 4-bitowym, aby zredukować liczbę potrzebnych linii GPIO. W tabeli 1 znajduje się spis kluczowych połączeń. Wszystko zasilane jest ze zwykłego zasilacza wtyczkowego.

Oprogramowanie

Na listingu 1 został pokazany kod skryptu, napisanego w Pythonie, który realizuje funkcjonalność urządzenia. System operacyjny powinien być skonfigurowany tak, aby skrypt uruchamiał się automatycznie, po starcie systemu.

Listing 1. Kod skryptu który realizuje funkcjonalność urządzenia

import Adafruit_CharLCD as LCD
import RPi.GPIO as GPIO
import time
from openalpr import Alpr
import sys
import cv2
from datetime import datetime
import os

button = 2
GPIO.setup(button,GPIO.IN)

# Konfiguracja pinów Raspberry Pi
lcd_rs = 21
lcd_en = 20
lcd_d4 = 16
lcd_d5 = 12
lcd_d6 = 7
lcd_d7 = 8

# Definicja wielkości LCD (domyślnie 16 znaków x 2 linie).
lcd_columns = 16
lcd_rows = 2

lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows)

plate_detected = False

alpr = Alpr("eu", "/home/pi/openalpr/src/build/config/openalpr.conf", "/home/pi/openalpr/runtime_data")

alpr.set_top_n(20)
alpr.set_default_region("md")

reset = True

while reset == True:
lcd.set_backlight(0)
lcd.clear()
print("Automatic Number Plate Detection")
lcd.message(‘ Raspberry pi\n Based ‘)
time.sleep(2)
lcd.clear()
lcd.message(‘Automatic Number\nPlate Detection’)
time.sleep(3)

lcd.clear()
lcd.message(‘Searching for\nCamera’)
print("Searching for Camera")
time.sleep(2)

camera=cv2.VideoCapture(0)

if not camera.isOpened():
main = False
print("can’t open the camera")
lcd.clear()
lcd.message(‘Error:Camera not\nFound’)
time.sleep(2)
lcd.clear()
lcd.message(‘Connect Camera &\npress reset’)
while GPIO.input(button) == True:
None

else:
main = True
print("camera found")
lcd.clear()
lcd.message(‘Found Camera’)
time.sleep(2)

while True:
ret, frame = camera.read()
results = alpr.recognize_file(frame)
i = 0
for plate in results[‘results’]:
i += 1
for candidate in plate[‘candidates’]:
prefix = "-"
if candidate[‘matches_template’]:
prefix = "*"
plate_detected = True
break
if plate_detected:
lcd.clear()
lcd.message(‘license plate \nno. is ‘+ candidate[‘plate’] )
plate_detected = False
else:
lcd.clear()
lcd.message(‘Plate not detected..’)
if GPIO.input(button) == False:
camera.release()
break

W pierwszej, konfiguracyjnej części skryptu, przy użyciu biblioteki GPIO uruchamiana jest obsługa przycisku. Następnie inicjalizowany jest ekran LCD. Jeśli w naszym systemie linie GPIO podłączone są do wyświetlacza w inny sposób niż opisano w tabeli 1, możliwa jest zmiana ich definicji w kodzie, tak, aby odpowiadały rzeczywistości.

Kluczowa część programu umieszczona jest w pętli while. Skrypt inicjalizuje kamerę przez funkcje z biblioteki OpenCV, a następnie pobiera z niej obraz i rozpoczyna jego analizę. Kluczowym elementem jest tutaj zastosowanie biblioteki OpenALPR, która służy do automatycznego rozpoznawania tablic rejestracyjnych i została napisana w C++. Metoda recognize_file() zwraca wynik w postaci listy results, w której znajduje się lista „kandydatów” (candidates) – rozpoznanych potencjalnych tablic rejestracyjnych. Skrypt sprawdza następnie, czy pasują one do zdefiniowanego szablonu i jeśli tak, ustawia flagę plate_detected. Jeśli jest ona ustawiona, skrypt ustawia na wyświetlaczu napis ze zidentyfikowaną tablicą rejestracyjną, korzystając z metody lcd.message.

Integracja systemu

Po skompletowaniu wszystkich komponentów sprzętowych, można przystąpić do uruchomienia systemu. W pierwszej kolejności należy umieścić kartę microSD w odpowiednim slocie w Raspberry Pi. Następnie podłączamy do Raspberry Pi kamerę, mysz, klawiaturę i ekran. Podłączamy również wyświetlacz LCD, z użyciem wspomnianej płytki lub w dowolny inny sposób. Nie pozostaje teraz nic innego, jak uruchomić system, podłączając zasilanie do Raspberry Pi i połączonych z nim elementów (pamiętajcie o zasileniu wyświetlacza LCD). Na fotografii 2 pokazano gotowy do działania system.

Fotografia 2. Zmontowana elektronika systemu do rozpoznawania tablic rejestracyjnych

Inicjalizacja i testy

Po uruchomieniu systemu operacyjnego należy przejść do folderu, w którym znajduje się plik Number plate Recognition.py ze skryptem z listingu 1. Uruchomienie skryptu spowoduje natychmiastowe zainicjowanie kamery i wyświetlacza LCD. Po aktywowaniu systemu warto upewnić się, że wyświetlacz LCD pokazuje informacje o poprawnym wykryciu kamery – w przeciwnym wypadku należy upewnić się, że wszystko zostało podłączone poprawnie, a kamera USB jest sprawna. Następnie wyświetlacz zacznie podawać zidentyfikowane numery tablic rejestracyjnych.