- Prerequisiti
- Passaggi coinvolti nel riconoscimento della targa utilizzando Raspberry Pi
- 1. Rilevamento targa
- 2. Segmentazione dei caratteri
- 3. Riconoscimento dei caratteri
- Casi falliti nel riconoscimento della targa
- Altri esempi di successo
La sicurezza è sempre stata una delle principali preoccupazioni dell'umanità. Oggi abbiamo telecamere di videosorveglianza nelle scuole, negli ospedali e in ogni altro luogo pubblico per farci sentire protetti. Secondo un sondaggio di HIS, si stima che nel 2014 ci fossero circa 245 milioni di telecamere di sicurezza installate e funzionanti, il che è come avere una telecamera di sicurezza ogni 30 persone su questo pianeta. Con il progresso della tecnologia, specialmente nell'elaborazione delle immagini e nell'apprendimento automatico, è possibile rendere queste telecamere più intelligenti addestrandole a elaborare le informazioni dal feed video.
Il feed video di queste telecamere può essere utilizzato per eseguire il riconoscimento del volto, l'analisi dei modelli, l'analisi delle emozioni e molto altro ancora che lo avvicinerebbero davvero a qualcosa come l '"occhio di Dio" mostrato nel film FF7. In effetti, società di sorveglianza come Hikvision e molte altre hanno già iniziato a implementare queste funzionalità nei loro prodotti. In precedenza abbiamo utilizzato l'elaborazione delle immagini MATLAB per leggere la targa, oggi in questo articolo impareremo come riconoscere e leggere il numero di targa dalle automobili utilizzando Raspberry Pi e OpenCV. Useremo alcune immagini di veicoli casuali da Google e scriveremo un programma per riconoscere la targa utilizzando OpenCV Contour Detection e quindi leggere il numero dalla targa utilizzando Tesseract OCR. Sembra interessante vero !, quindi iniziamo.
Prerequisiti
Come detto in precedenza, utilizzeremo la libreria OpenCV per rilevare e riconoscere i volti. Quindi assicurati di installare OpenCV Library su Raspberry Pi prima di procedere con questo tutorial. Alimenta anche il tuo Pi con un adattatore 2A e collegalo a un monitor per un debug più semplice.
Questo tutorial non spiegherà come funziona esattamente OpenCV, se sei interessato ad apprendere l'elaborazione delle immagini, dai un'occhiata a queste basi di OpenCV e ai tutorial avanzati sull'elaborazione delle immagini. Puoi anche conoscere i contorni, il rilevamento dei blob ecc. In questo tutorial sulla segmentazione delle immagini utilizzando OpenCV. Faremo qualcosa di simile a questo per rilevare la targa dell'auto dall'immagine.
Passaggi coinvolti nel riconoscimento della targa utilizzando Raspberry Pi
Il riconoscimento della targa o LPR in breve, comporta tre passaggi principali. i passi sono come segue
1. Rilevamento targa: il primo passo è rilevare la targa dall'auto. Useremo l'opzione contorno in OpenCV per rilevare oggetti rettangolari per trovare la targa. La precisione può essere migliorata se conosciamo le dimensioni esatte, il colore e la posizione approssimativa della targa. Normalmente l'algoritmo di rilevamento viene addestrato in base alla posizione della telecamera e al tipo di targa utilizzata in quel particolare paese. Questo diventa più complicato se l'immagine non ha nemmeno un'auto, in questo caso faremo un ulteriore passaggio per rilevare l'auto e quindi la targa.
2. Segmentazione dei caratteri: una volta rilevata la targa, dobbiamo ritagliarla e salvarla come nuova immagine. Anche in questo caso è possibile farlo facilmente utilizzando OpenCV.
3. Riconoscimento dei caratteri: ora, la nuova immagine che abbiamo ottenuto nel passaggio precedente avrà sicuramente alcuni caratteri (numeri / alfabeti) scritti su di essa. Quindi, possiamo eseguire OCR (Optical Character Recognition) su di esso per rilevare il numero. Abbiamo già spiegato il riconoscimento ottico dei caratteri (OCR) utilizzando Raspberry Pi.
1. Rilevamento targa
Il primo passo in questo lettore di targhe Raspberry Pi è rilevare la targa. Facciamo un'immagine di esempio di un'auto e iniziamo con il rilevamento della targa su quell'auto. Useremo quindi la stessa immagine anche per la segmentazione dei caratteri e il riconoscimento dei caratteri. Se vuoi passare direttamente al codice senza spiegazioni, puoi scorrere fino alla fine di questa pagina, dove viene fornito il codice completo. L'immagine di prova che sto usando per questo tutorial è mostrata di seguito.
Passaggio 1: ridimensionare l'immagine alla dimensione richiesta e quindi ridimensionarla in scala di grigi. Il codice per lo stesso è dato di seguito
img = cv2.resize (img, (620,480)) gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) #convert to gray scale
Ridimensionando ci aiutiamo ad evitare problemi con immagini a risoluzione maggiore, assicurandoci che la targa rimanga ancora nel telaio dopo il ridimensionamento. La scala dei grigi è comune in tutte le fasi di elaborazione delle immagini. Questo accelera altri processi successivi poiché non dobbiamo più occuparci dei dettagli del colore durante l'elaborazione di un'immagine. L'immagine verrebbe trasformata in questo modo una volta completato questo passaggio
Step 2: Ogni immagine avrà informazioni utili e inutili, in questo caso per noi solo la targa è l'informazione utile il resto è praticamente inutile per il nostro programma. Questa informazione inutile si chiama rumore. Normalmente l' utilizzo di un filtro bilaterale (Sfocatura) rimuoverà i dettagli indesiderati da un'immagine. Il codice per lo stesso è
grigio = cv2.bilateralFilter (grigio, 11, 17, 17)
La sintassi è destination_image = cv2.bilateralFilter (source_image, diametro del pixel, sigmaColor, sigmaSpace). Puoi aumentare il colore sigma e lo spazio sigma da 17 a valori più alti per sfocare più informazioni sullo sfondo, ma fai attenzione che la parte utile non venga sfocata. L'immagine di output è mostrata di seguito, come puoi vedere i dettagli dello sfondo (albero e edificio) sono sfocati in questa immagine. In questo modo possiamo evitare che il programma si concentri successivamente su queste regioni.
Passaggio 3: il passaggio successivo è interessante in cui eseguiamo il rilevamento dei bordi. Ci sono molti modi per farlo, il modo più semplice e popolare è usare il metodo canny edge di OpenCV. La linea per fare lo stesso è mostrata di seguito
edged = cv2.Canny (gray, 30, 200) #Perform Edge detection
La sintassi sarà destination_image = cv2.Canny (source_image, thresholdValue 1, thresholdValue 2). Il valore di soglia 1 e il valore di soglia 2 sono i valori di soglia minimo e massimo. Verranno visualizzati solo i bordi che hanno un gradiente di intensità superiore al valore di soglia minimo e inferiore al valore di soglia massimo. L'immagine risultante è mostrata di seguito
Passaggio 4: ora possiamo iniziare a cercare i contorni sulla nostra immagine, abbiamo già imparato come trovare i contorni usando OpenCV nel nostro tutorial precedente, quindi procediamo allo stesso modo.
nts = cv2.findContours (edged.copy (), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours (cnts) cnts = ordinato (cnts, key = cv2.contourArea, reverse = True) screenCnt = Nessuno
Una volta rilevati i contatori, li ordiniamo da grandi a piccoli e consideriamo solo i primi 10 risultati ignorando gli altri. Nella nostra immagine il contatore potrebbe essere qualsiasi cosa che abbia una superficie chiusa ma di tutti i risultati ottenuti ci sarà anche il numero di targa poiché è anche una superficie chiusa.
Per filtrare l'immagine della targa tra i risultati ottenuti, eseguiremo un loop di tutti i risultati e controlleremo quale ha un contorno di forma rettangolare con quattro lati e una figura chiusa. Dal momento che una targa sarebbe sicuramente una figura rettangolare a quattro lati.
# loop sui nostri contorni per c in cnts: # approssima il contorno peri = cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, 0.018 * peri, True) # se il nostro contorno approssimato ha quattro punti, # noi possiamo supporre di aver trovato il nostro schermo se len (approx) == 4: screenCnt = approx break
Il valore 0,018 è un valore sperimentale; puoi giocarci intorno per verificare quale funziona meglio per te. Oppure portalo al livello successivo utilizzando l'apprendimento automatico per allenarti in base alle immagini delle auto e quindi utilizzare il valore giusto lì. Una volta trovato il contatore giusto, lo salviamo in una variabile chiamata screenCnt e quindi disegniamo un rettangolo attorno ad esso per assicurarci di aver rilevato correttamente la targa.
Passaggio 5: ora che sappiamo dove si trova la targa, le informazioni rimanenti sono praticamente inutili per noi. Quindi possiamo procedere con la mascheratura dell'intera immagine ad eccezione del luogo in cui si trova la targa. Il codice per fare lo stesso è mostrato di seguito
# Mascherando la parte diversa dalla targa mask = np.zeros (gray.shape, np.uint8) new_image = cv2.drawContours (mask,, 0,255, -1,) new_image = cv2.bitwise_and (img, img, mask = maschera)
La nuova immagine mascherata apparirà come di seguito
2. Segmentazione dei caratteri
Il passaggio successivo nel riconoscimento della targa Raspberry Pi consiste nel segmentare la targa fuori dall'immagine ritagliandola e salvandola come nuova immagine. Possiamo quindi utilizzare questa immagine per rilevare il personaggio al suo interno. Il codice per ritagliare l'immagine roi (regione di interesse) dall'immagine principale è mostrato di seguito
# Ora ritaglia (x, y) = np.where (mask == 255) (topx, topy) = (np.min (x), np.min (y)) (bottomx, bottomy) = (np.max (x), np.max (y)) Ritagliata = grigio
L'immagine risultante è mostrata di seguito. Normalmente aggiunto al ritaglio dell'immagine, possiamo anche renderla grigia e bordarla se necessario. Questo viene fatto per migliorare il riconoscimento dei caratteri nella fase successiva. Tuttavia ho scoperto che funziona bene anche con l'immagine originale.
3. Riconoscimento dei caratteri
Il passaggio finale in questo riconoscimento della targa Raspberry Pi è leggere effettivamente le informazioni sulla targa dall'immagine segmentata. Useremo il pacchetto pytesseract per leggere i caratteri dall'immagine, proprio come abbiamo fatto nel tutorial precedente. Il codice per lo stesso è dato di seguito
#Read the number plate text = pytesseract.image_to_string (Cropped, config = '- psm 11') print ("Detected Number is:", text)
Abbiamo già spiegato come configurare un motore Tesseract, quindi anche qui se necessario possiamo configurare il Tesseract OCR per ottenere risultati migliori se necessario. Il carattere rilevato viene quindi stampato sulla console. Una volta compilato, il risultato viene mostrato come di seguito
Come puoi vedere l'immagine originale aveva il numero "HR 25 BR9044" e il nostro programma ha rilevato che ha stampato lo stesso valore sullo schermo.
Casi falliti nel riconoscimento della targa
Il file di progetto completo di questo Raspberry Pi License Plate Recognition può essere scaricato da qui, contiene il programma e le immagini di prova che abbiamo utilizzato per controllare il nostro programma. Senza essere detto, è da ricordare che i risultati di questo metodo non saranno accurati . La precisione dipende dalla chiarezza dell'immagine, dall'orientamento, dall'esposizione alla luce, ecc. Per ottenere risultati migliori puoi provare a implementare algoritmi di Machine learning insieme a questo.
Per avere un'idea, diamo un'occhiata a un altro esempio in cui l'auto non è rivolta direttamente alla telecamera.
Come puoi vedere, il nostro programma è stato in grado di rilevare correttamente la targa e ritagliarla. Ma la libreria Tesseract non è riuscita a riconoscere correttamente i personaggi. Invece dell'attuale "TS 08 UE 3396", l'OCR ha riconosciuto che è "1508 ye 3396". Problemi come questo possono essere corretti utilizzando immagini di orientamento migliori o configurando il motore Tesseract .
Un altro scenario peggiore è quello in cui il contorno non riesce a rilevare correttamente la targa. L'immagine sotto ha troppe informazioni di sfondo e una cattiva illuminazione che il programma non è nemmeno riuscito a identificare la targa dal numero. In questo caso dobbiamo fare di nuovo affidamento sull'apprendimento automatico o migliorare la qualità dell'immagine.
Altri esempi di successo
La maggior parte delle volte la qualità dell'immagine e l'orientamento sono corretti, il programma è stato in grado di identificare la targa e leggere il numero da essa. Le istantanee di seguito mostrano alcuni dei risultati positivi ottenuti. Anche in questo caso tutte le immagini di prova e il codice qui utilizzato saranno disponibili nel file ZIP fornito qui.
Spero che tu abbia capito il riconoscimento automatico della targa utilizzando Raspberry Pi e ti sia piaciuto costruire qualcosa di interessante da solo. Cos'altro pensi si possa fare con OpenCV e Tesseract ?, Fammi sapere i tuoi pensieri nella sezione commenti. Se hai domande su questo articolo, non esitare a lasciarle nella sezione commenti qui sotto o usa i forum per altre domande tecniche.