Sistema di riconoscimento targhe · Matteo Dalponte Tesina di Maturità A.S: 2014/2015 7 Hardware e il software libero 2.1 Caratteristiche Hardware: Raspberry Pi è un computer delle

An

no

sco

last

ico

: 2

01

4/2

01

5

Mat

teo

Dal

po

nte

Sis

tem

a d

i ri

con

osc

ime

nto

ta

rgh

e

Matteo Dalponte Tesina di maturità

Anno Scolastico 2014-2015

Sviluppo di un sistema di riconoscimento targhe e gestione degli accessi per una zona a traffico limitato o un parcheggio protetto da barriera automatica

Matteo Dalponte Tesina di Maturità A.S: 2014/2015

2

Indice

La mia passione per l'automazione .............................................................................. 3

Il sistema: Caratteristiche principali............................................................................. 5

1.1 Funzionamento Generale ........................................................................................................ 5

1.2 ANPR Specifiche tecniche ........................................................................................................ 6

Hardware e il software libero ...................................................................................... 7

2.1 Caratteristiche Hardware: ....................................................................................................... 7

2.2 Il software progettato: ............................................................................................................ 8

2.3 Cos'è Linux? ........................................................................................................................... 10

2.4 Il Software Libero: ................................................................................................................. 10

Approfondimento .......................................................................................................12

3.1 IP camera e protocollo MJPEG .............................................................................................. 12

3.2 Python ................................................................................................................................... 13

3.3 Gestione dati OCR ................................................................................................................. 14

Il codice sorgente .......................................................................................................16

4.1 Lettura OCR e transizione dati ............................................................................................... 16

4.2 GUI Visualizzazione streaming ............................................................................................... 22

Sitografia .....................................................................................................................29


3

La mia passione per l'automazione

L'automazione, il controllo remoto, la gestione delle immagini e la comunicazione dei dati

attraverso l'etere sono argomenti che da sempre mi affascinano; così tre anni fa ho deciso

di seguire un corso extrascolastico di programmazione Arduino tenuto nei laboratori di

fisica della Scuola, con l'obiettivo di imparare ad utilizzare la board Arduino.

Il corso, che ho seguito per tutto l'anno, mi ha permesso di entrare nella logica della

programmazione, di imparare le basi del linguaggio C e di confrontarmi con tante altre

persone che condividono la stessa passione.

Alla fine della terza, grazie alle competenze

acquisite durante il corso, ho sviluppato e

venduto due sistemi automatici di cui uno

per la gestione dell'energia prodotta da una

piccola centrale idroelettrica (v. foto); il

sistema costruito è incaricato di misurare i

parametri di corrente, potenza e tensione in

ingresso al pacco batterie mantenute in

carica dal generatore della turbina, visualizzarli

sul un display e fungere da regolatore di carica per le batterie.

Nel caso in cui la tensione superi un certo valore preimpostato, per esempio di notte

quando la l'energia non viene completamente utilizzata, viene attivato un boiler che ha la

duplice funzione di riportare la tensione delle batterie nel range di carica e allo stesso

tempo scaldare acqua sanitaria; in questo modo tutta l'energia prodotta dall'impianto

viene sfruttata a pieno.

Il secondo sistema sviluppato è stato progettato per integrare sul quadro strumenti di una

moto ulteriori informazioni quali il numero di giri del motore e lo stato di carica della

batteria di avviamento.

Per la lettura del numero di giri, senza integrare ulteriore sensoristica, ho scelto di

interfacciare l'apparecchio con il sistema di accensione (che pilota il l'arco elettrico della

candela), naturalmente già presente sul veicolo.

Durante l'estate, poi, è nato un nuovo progetto, il cui obiettivo era quello di controllare un

modellino di macchina da un computer e visualizzarne il video in diretta per il controllo a

distanza. Tale progetto mi ha portato alla scoperta di nuove schede (Raspberry Pi per

esempio), differenti da Arduino, e programmabili con nuovi linguaggi.

Così, da autodidatta, ho imparato le basi della programmazione in Python, il

funzionamento del sistema operativo GNU/Linux e i sistemi di gestione e trasmissione dati

via etere (Mikrotik).

Le potenzialità del controllo a distanza sono state apprezzate da un modellista che ha

intravisto la possibilità di controllare droni a distanza e di visualizzarne il video in diretta ed

in alta definizione.


4

Così, assieme ad Andrea abbiamo iniziato un'avventura nel modellismo tradizionale,

imparando a guidare quadricotteri e parallelamente creando modelli intelligenti in grado di

"guidarsi da soli".

Il progetto ci ha portato alla scoperta di tecnologie sempre più evolute e per ora siamo

riusciti a creare un modello di esacottero per riprese aeree in grado di pilotarsi

completamente in modo autonomo, seguendo solamente una mappa disegnata dalla

stazione a terra.

Per le prossime migliorie è in progetto lo studio di un sistema più evoluto di gestione del

video per il controllo a distanza e la realizzazione di modelli tridimensionali di edifici e

terreni filmati.

Verso la metà di questo anno scolastico ci è stato proposto di prendere parte al progetto

Tu Sei, in collaborazione con Confindustria, così è nata l'idea di realizzare la tesina

sull'automazione di un cancello tramite un sistema di riconoscimento targhe.

Il progetto in fase di sviluppo è stato presentato alla ditta Algorab di Lavis, ma il lavoro, alla

fine, è stato svolto esclusivamente da me e dal mio compagno di classe Andrea.

Il nostro lavoro, che ha ricevuto un'ottima valutazione dalla ditta Algorab, in data 22

maggio è stato presentato alla commissione di valutazione del progetto Tu Sei, che ha

riconosciuto alla scuola una menzione speciale.

In allegato la fotocopia dell'attestato di riconoscimento della commissione e la valutazione

della ditta.

Sistema di gestione della carica delle batterie e dell'utilizzo dell'energia proveniente da un piccolo impianto idroelettrico - fotovoltaico stand alone

Esacottero per riprese aeree (eliche 45 CM)


5

Il sistema: Caratteristiche principali

1.1 Funzionamento Generale

Il sistema sviluppato ha come obbiettivo principale la gestione degli accessi di veicoli in

un'area riservata ad alta affluenza.

Il problema è tutt'altro che banale e dipende da numerosi fattori, primi tra tutti il costo del

sistema di gestione e la sicurezza degli accessi.

La soluzione più utilizzata ad oggi si basa su un sistema di lettura di chiavi elettroniche,

soluzione efficace e sicura, ma di costo crescente all'aumentare del numero di utenti.

L'innovazione proposta dal nostro sistema prevede un riconoscimento automatico dei

veicoli autorizzati tramite la lettura della targa.

Il riconoscimento automatico delle targhe (ANPR Automatic number plate recognition) è

una tecnologia che utilizza il riconoscimento ottico dei caratteri sulle immagini per leggere

le targhe dei veicoli.

Il sistema è solitamente utilizzato dalle forze dell'ordine per il controllo della velocità

(Tutor), come metodo di telepedaggio per gli ingressi alle autostrade, la catalogazione dei

movimenti di traffico o individui, il controllo dell'accesso a zone a traffico limitato o

l'accesso a parcheggi con barriera.

Il principio di funzionamento si basa sull’acquisizione tramite telecamera dell'immagine,

l’elaborazione e l’ottimizzazione della stessa , il riconoscimento e la

conversione in stringa del valore della targa tramite un software

OCR (optical character recognition).

Nel nostro caso il sistema

viene posto a controllo di

un ingresso

parcheggio e quindi

un secondo step è necessario al fine di verificare la

corrispondenza della stringa fornita dall'OCR con un database,

decidere se al veicolo è consentito l'accesso e, in caso positivo,

comandare il sistema di apertura.

Per fare tutto ciò è stato sviluppato un software, in grado di lavorare su un hardware con

potenza di calcolo medio-bassa, al fine di portare il sistema ad un buon compromesso

prezzo-qualità per fornire la possibilità di installazione anche ad utenze private ad un

prezzo accessibile.

Figura1: Funzionamento generale


6

1.2 ANPR Specifiche tecniche

La lettura automatica del numero di targa consiste nel trasformare i pixel dell'immagine

digitale in testo ASCII della targa.

La tecnologia di riconoscimento ottico dei caratteri (OCR) utilizzata per ANPR è molto simile

alla tecnologia che consente di acquisire documenti cartacei e trasformarli in file

elettronici modificabili (software in grado di costruire documenti word da un testo

acquisito a scanner).

Ci sono sette algoritmi primari che il software deve eseguire per arrivare all'identificazione

di una targa:

Localizzazione targa - necessità di trovare e isolare la targa sull'immagine acquisita

Orientamento targa e ridimensionamento - viene corretta un'eventuale inclinazione

della targa e ne viene regolata la dimensione

Regolazione luminosità e contrasto

Segmentazione in caratteri - trova i singoli caratteri sulla targa e li divide in singoli

frame

Riconoscimento ottico dei caratteri

Analisi Sintattica / Geometrica - viene verificato se i caratteri rispettano le specifiche

per paese

Eventuale media del riconoscimento su più immagini, per produrre un risultato più

affidabile e sicuro

Il sistema di riconoscimento non è preciso al 100%, infatti presenta alcuni limiti che

possono derivare da uno o più dei seguenti fattori:

Risoluzione del video scadente, solitamente dovuta al tentativo di riconoscimento di

una targa troppo lontana, ma talvolta risultante dall'uso di una telecamera di bassa

qualità

Immagini sfocate, soprattutto se il veicolo è in movimento

Scarsa illuminazione, basso contrasto o sovraesposizione, riflessione o presenza di

ombre

Un oscuramento della targa da parte di un oggetto, molto spesso una barra di traino

o sporcizia

Caratteri differenti (i caratteri delle targhe possono variare da paese a paese)

Tecniche di elusione

E' importante sottolineare che i sistemi di riconoscimento potrebbero portare a violazioni

della normativa sulla privacy, in quanto idonei a tracciare i movimenti dei cittadini.


7

Hardware e il software libero

2.1 Caratteristiche Hardware:

Raspberry Pi è un computer delle dimensioni di una carta

di credito e del costo medio di circa 30€.

Il prodotto nasce in un primo momento con lo scopo di

portare nelle scuole elaboratori economici, utili per

l’insegnamento dell’informatica.

Grazie al grande successo riscosso presso gli istituti scolastici più

aperti all’innovazione, la voce dell’esistenza di questo piccolo computer

campione di versatilità si è estesa generando un commercio di centinaia di migliaia di unità

e coinvolgendo i settori più disparati.

Sono stati (e sono tuttora) davvero tanti gli utenti a voler scegliere RaspberryPi, dagli

hacker più esperti

ai giovani che

desiderano

avvicinarsi al

mondo

dell’informatica, senza

spendere un capitale.

Dal punto di vista tecnico non sono le prestazioni

che fanno gridare al miracolo, ma è la buona

espandibilità dell’hardware e la sua versatilità,

unita alla versatilità dei sistemi operativi Linux che

supporta: sono questi i

fattori che hanno

portato ad una larga

diffusione del

prodotto.

La scheda che abbiamo deciso di adottare per lo sviluppo e la messa in opera del progetto

si chiama Banana Pi ed è un'evoluzione del tradizionale Raspberry, meno conosciuta, un po'

più costosa, ma dalle prestazioni maggiori, fattore quest'ultimo di fondamentale

importanza per il processing video e delle immagini.

E' stato finora descritto l'hardware più importante del progetto, ma sono stati anche

utilizzati: Arduino ed una telecamera (descrizione al punto 3.1)

Inoltre è stata realizzata una scheda relay che consente di interfacciare la sensoristica già

presente sul cancello (fotocellula, barriere a pressione, chiave per apertura) con Arduino.

Figura 2: Hardware Low-Cost utilizzato

Figura 3: collegamenti Hardware


8

2.2 Il software progettato:

Oltre all'hardware in questo progetto gioca un ruolo fondamentale il software.

Su Banana Pi è infatti necessario eseguire diversi software che devono essere coordinati e

gestiti in modo simultaneo con differenti velocità di esecuzione.

Tutto ciò viene gestito dal Kernel Linux, approfondito nella sezione 2.3 .

A grandi linee si può dire che il sistema è così strutturato:

I dati provenienti dalla telecamera su interfaccia USB vengono decodificati dal modulo di

gestione delle periferiche video interno al Kernel denominato video fot linux (V4L).

Questi dati decodificati vengono letti dal noto riproduttore video VLC che nel nostro caso,

configurato in modo adeguato, sarà incaricato di creare il flusso streaming MJPEG

(approfondimento sezione 3.1).

Il flusso viene reso accessibile sulla rete locale tramite porta ethernet per la visualizzazione

da remoto e allo stesso tempo verrà mandato al sistema di gestione fotogrammi e

riconoscimento ottico (OCR) per la conversione in stringa del valore della targa.

La stringa viene poi spedita in un "contenitore" (approfondimento sezione 3.3) che fungerà

da tramite tra l'OCR ed il software di gestione database.

Un software scritto in python (codice sorgente sezione 4.1) esegue il confronto tra la targa

letta dall'OCR e il database e, in caso di un riscontro, gestisce l'apertura del cancello ed

inserisce i dati relativi al proprietario della targa in un file di scambio.

Il file di scambio e il file del database vengono resi disponibili sulla rete locale LAN tramite

un server FTP, grazie al quale un qualsiasi computer autenticato nella rete potrà aggiungere

o eliminare le targhe dal database e leggere il file di scambio.

Su un pc della rete locale LAN viene installato un software progettato appositamente per la

gestione del database e per la visualizzazione in tempo reale dello streaming(codice

sorgente sez. 4.2).

Di seguito alcune immagini che mostrano il software di gestione database:


9

Funzionamento software schematizzato in uno schema a blocchi


10

2.3 Cos'è Linux?

Linux è un sistema operativo, ovvero quell'insieme di programmi essenziali

per far funzionare il computer . E' una alternativa a Windows e a MacOS,

e può essere installato al loro posto (o insieme, sullo stesso computer).

Più in generale Linux è il primo rappresentante del ("freesoftware", in

inglese), ovvero quel software distribuito con una licenza che ne

permette non solo l'utilizzo da parte di chiunque ed in qualsiasi

circostanza, ma anche la modifica, la copia e l'analisi.

Linux è un sistema operativo sviluppato da Linus Torvalds; in gergo

tecnico è più corretto denominare Linux come kernel, cioè cuore del sistema; attorno ad

esso girano applicazioni di varia natura che sfruttano le sue potenzialità. L'idea originaria di

Linus Torvalds fu quella di migliorare un kernel già esistente, Minix, creato per scopi

didattici da Andrew S.Tanenbaum. La particolarità di Linux è che il progetto di sviluppo

attorno al kernel è stato realizzato sia da esperti che da semplici appassionati ed hacker di

tutto il mondo, grazie al coordinamento ed alla diffusione dei dati tramite Internet.

Questa collaborazione ha portato alla nascita di un sistema operativo realmente in grado di

essere antagonista a Windows.

Il nome più corretto per indicarlo è in realtà GNU/Linux, in quanto le applicazioni

fondamentali (compilatori, editor, librerie, etc.) sono state sviluppate dalla Free Software

Foundation di Richard Stallman alla cui base c'è il progetto GNU (Gnu's not Unix), ovvero la

realizzazione di un sistema operativo libero di cui possiamo elencare le principali

caratteristiche relative alla licenza di distribuzione GPL (General Public License):

codice sorgente aperto e disponibile per la lettura e la modifica;

libera distribuzione, da parte di chiunque, sia del software che del relativo codice

sorgente;

applicazioni e prodotti derivati coperti sempre da licenza GPL (copyleft);

libero utilizzo anche per fini di natura commerciale.

2.4 Il Software Libero:

L'idea di software libero nasce agli inizi degli anni

Ottanta, quando lo sviluppo del software

cominciò a passare dalle università alle aziende

(software proprietario), ponendo un pesante

freno alla collaborazione che caratterizzava il

lavoro di gran parte dei programmatori e dei

sistemisti dell'epoca, soprattutto con i patti di

Figura 4: Stemma S.O. GNU/Linux

Figura 5: Stemma Free Software Foundation

http://it.wikipedia.org/wiki/Anni_1980



http://it.wikipedia.org/wiki/Software_proprietario


11

non divulgazione che le aziende facevano firmare ai programmatori assunti.

In realtà il software "commerciale" esisteva già, ma i costi elevati dell'hardware facevano

sì che il business delle aziende non fosse concentrato sul software, che era considerato una

parte naturale del prodotto, ed i cui file sorgente erano in genere di dominio pubblico.

Con il passare del tempo il software diventò sempre più complesso e difficile da realizzare e

le aziende iniziarono a non distribuire i file sorgente obbligando i propri dipendenti a non

rivelare nulla per non avvantaggiare la concorrenza; inoltre con il crollo dei costi

dell'hardware, lo sviluppo commerciale del software divenne un business notevole, ed il

codice sorgente era divenuto un investimento prezioso che poteva, da un lato far acquisire

una fetta di tale mercato in rapida crescita e dall'altro legare i propri utenti al proprio

software mantenendo il segreto sui metodi utilizzati per lo sviluppo di sistemi e

applicazioni.

In questo modo le aziende cominciarono ad utilizzare la legge sul diritto d'autore per

impedire ai concorrenti di leggere e modificare i loro prodotti, assicurandosi il controllo dei

propri clienti che, senza poter vedere e modificare il codice sorgente del software, non

potevano più adattarlo alle loro esigenze, ed erano così costretti ad acquistare servizi di

supporto dalle aziende fornitrici.

Nel 1983 Richard Stallman fondò il progetto GNU con l'intenzione di creare un sistema

operativo completamente libero. Grazie alla collaborazione di molti sviluppatori volontari,

all'uso di Internet per il coordinamento del progetto ed al kernel Linux di Linus Torvalds,

nel 1991 nacque GNU/Linux, un clone di Unix liberamente utilizzabile, modificabile e

ridistribuibile.

Il movimento per il software libero si batte, quindi, per dare agli utenti di sistemi

informatici la libertà che deriva dal software libero. Il software libero dà, a chi lo usa, il

controllo delle proprie elaborazioni informatiche, mentre il software non libero pone chi lo

usa sotto il dominio dello sviluppatore.

Secondo la Free Software Foundation, un software si può definire libero solo se garantisce

quattro "libertà fondamentali":

Libertà 1: Libertà di eseguire il programma per qualsiasi scopo.

Libertà 2: Libertà di studiare il programma e modificarlo.

Libertà 3: Libertà di ridistribuire copie del programma in modo da aiutare il

prossimo.

Libertà 4: Libertà di migliorare il programma e di distribuirne pubblicamente i

miglioramenti, in modo tale che tutta la comunità ne tragga beneficio.

http://it.wikipedia.org/wiki/Hardware

http://it.wikipedia.org/wiki/Diritto_d%27autore

http://it.wikipedia.org/wiki/1983

http://it.wikipedia.org/wiki/Richard_Stallman

http://it.wikipedia.org/wiki/Progetto_GNU

http://it.wikipedia.org/wiki/Sistema_operativo



http://it.wikipedia.org/wiki/Internet

http://it.wikipedia.org/wiki/Kernel_Linux

http://it.wikipedia.org/wiki/Linus_Torvalds

http://it.wikipedia.org/wiki/1991

http://it.wikipedia.org/wiki/GNU/Linux

http://it.wikipedia.org/wiki/Unix

http://it.wikipedia.org/wiki/Free_Software_Foundation


12

Approfondimento

3.1 IP camera e protocollo MJPEG

Il Sistema hardware è costituito da una telecamera USB che, interfacciata con VLC come

descritto nella sezione 2.2, è in grado di creare un flusso

video digitale formato M-JPEG collocato in rete su

protocollo HTTP e fisicamente trasportato tramite

cavo di rete ethernet; sfruttando questa

configurazione il sistema, a differenza della

tecnologia analogica su cavo coassiale, non risente

della perdita di qualità dell'immagine.

La scelta del tipo di formato è stata vincolata dalla

libreria incaricata di migliorare i singoli fotogrammi

delle immagini contenenti la targa.

Infatti per la sua struttura "grezza" il formato MJPEG non

richiede processori di alto livello per comporre il flusso(nel

Banana Pi) e poi per scomporlo nuovamente in singoli fotogrammi per l'analisi(nel PC di

controllo), ma la velocità di trasmissione tra i due hardware richiesta dalla rete è

considerevole.

Il software basato sul protocollo MJPEG acquisisce dal sensore ottico singole foto

(solitamente ad una velocità di 30 al secondo), le codifica nel formato JPEG per ridurne la

qualità e la dimensione e poi le manda in sequenza al client, che visualizza il flusso video

come una sequenza di foto.

Per fare un confronto con la recentissima tecnologia H264 o MPEG2 (utilizzata per esempio

nella trasmissione della tv digitale) possiamo dire che le ultime due hanno una

compressione intraframe; ciò significa che se il fotogramma precedente conteneva la

stessa immagine del successivo frame non viene inviata al client nessuna nuova immagine

e quindi verrà mostrata l'ultima ricevuta; nel caso in cui il frame successivo cambi alcune

sue parti rispetto al precedente, il protocollo h264 prevede l'invio solo delle parti

modificate.

In questo caso, a parità di qualità di immagine, la rete viene utilizzata anche 10 volte

meno, ma sia il processore di codifica che quello di decodifica vengono utilizzati

maggiormente.

Figura 6: Speciale IP camera con visore 360°


13

3.2 Python

L'intero software a bordo di Banana Pi per la gestione dei caratteri

digitalizzati provenienti dall'OCR, per il confronto con il database e

per la gestione della comunicazione seriale con Arduino è

interamente scritto in python.

Analogamente è gestito con python anche il software di controllo in

grado di gestire sul Pc il database delle targhe consentite e di riprodurre il

video streaming.

Perché proprio Python e non C, Java, Visual Basik o Perl?

Python è innanzitutto un linguaggio di script pseudocompilato.

Questo significa che, similmente a Perl ed a Tcl/Tk, ogni programma sorgente deve essere

pseudocompilato da un interprete. L'interprete è un normale programma che va installato

sulla propria macchina e si occupa di interpretare il codice sorgente e di eseguirlo.

Quindi, diversamente da C++, non abbiamo una fase di compilazione che trasforma il

codice sorgente in file eseguibile, ma esiste solo il sorgente che viene eseguito

dall'interprete.

Il fatto di essere pseudocompilato rende Python un linguaggio portabile. Una volta scritto

un sorgente, esso può essere interpretato ed eseguito sulla gran parte delle piattaforme

attualmente utilizzate come Apple (Mac) o PC (Microsoft Windows e GNU/Linux),

disponendo semplicemente di una versione corretta dell'interprete.

Python non è attualmente il linguaggio di programmazione più famoso (v. Figura 8), ma viene spesso utilizzato per creare codici sorgente destinati ad hardware tipo Raspberry Pi. Inoltre la documentazione e le librerie a disposizione sulla rete sono numerose.

Figura 7: Stemma del linguaggio di programmazione Python

Figura 8: Statistica relativa ai linguaggi di programmazione più utilizzati (fonte: TIOBE Software)


14

3.3 Gestione dati OCR

Verrà ora proposta la soluzione ad uno dei problemi riscontrati durante lo sviluppo del

progetto, tutto il restante codice sorgente è, con i relativi commenti, disponibile a seguire.

Il software optical character recognition (OCR), dopo aver effettuato la lettura

dell'immagine, deve comunicare al software di gestione database la stringa contenente il

valore della targa.

Il software ocr ed il software di gestione database e accessi sono scritti in linguaggi

differenti, quindi è necessario trovare un sistema comune per comunicare i dati.

La soluzione è l'utilizzo delle code beanstalkd. Il sistema prevede un contenitore centrale

(software beanstalkd) in cui vengono inseriti dei dati dall'alto e prelevati dal basso.

In questo modo il software che legge i dati

potrà leggerli quando vorrà scaricandoli dal

"contenitore" e non dovrà essere sempre in

ascolto.

Per la gestione di questo contenitore sono presenti diverse

librerie per tutti i linguaggi di programmazione: in questo

modo un software scritto ad esempio in C potrà caricare i dati,

mentre uno scritto in Python potrà scaricarli e, data la presenza

delle code beanstalkd, il software più veloce non verrà rallentato da quello più lento.

Sarà poi necessario trasportare i dati in un formato standard facile da dividere e da

interpretare per i diversi linguaggi di programmazione.

Per la soluzione a questo secondo problema risulta particolarmente adatto il sistema JSON

(JavaScript Object Notation), un formato studiato per lo scambio dei dati in applicazioni

client-server.

Python gestisce il sistema json come una serie di librerie e dizionari.

Per capire meglio la struttura di un elemento json è necessario avere chiari i seguenti

concetti:

le liste in Python sono collezioni ordinate di oggetti, simili agli array di altri linguaggi di

programmazione come Java. In altre parole permettono di memorizzare una sequenza di

oggetti ed accedere ad essi mediante un indice.

es:

>>> lista=[1, 'html'] # lista con un intero e una stringa

(>>> significa comando eseguito direttamente nella shell,

si utilizza # in Python per aggiungere commenti )

Per recuperare un valore da una lista è sufficiente richiamare la posizione

es:

>>> lista[1] # indicizzazione

'html'

Figura 9: Sistema di gestione code


15

Un dizionario invece rappresenta una collezione “non ordinata” di oggetti. Gli oggetti sono identificati univocamente da una chiave (generalmente una stringa) invece che mediante un indice numerico, come avviene nelle liste.

Ogni elemento del dizionario è rappresentato da una coppia (chiave : valore), la chiave serve per accedere all’elemento e recuperare il valore.

es:

>>> diz={'html':1, 'HTML':2, 'HTml':3}

Per recuperare un valore da un dizionario è sufficiente richiamare la posizione

es:

>>> diz['HTML'] #ottieni valore richiamando la chiave

2

Analizzando bene il json in uscita all'OCR possiamo vedere come i dati effettivamente

siano divisi in liste e dizionari.

{

"uuid": "e11ecc-6aaf-47-929-9e67",

"camera_id": 1,

"site_id": "watchtower-hq",

"img_width": 640,

"img_height": 480,

"epoch_time": 1402161050,

"processing_time_ms": 138.669163,

"results": [

{

"plate": "S11FRE",

"confidence": 77.130661,

"matches_template": 0,

"region": "",

"region_confidence": 0,

"coordinates": [

{

"x": 218,

"y": 342

},

{

"x": 407,

"y": 325

},

{

"x": 407,

"y": 413

},

{

"x": 218,


16

"y": 431

}

],

"candidates": [

{

"plate": "S11FRE",


"matches_template": 0

},

{

"plate": "S11ERE",


"matches_template": 0

}

]

}

]

}

Per esempio se noi dovessimo recuperare il numero di targa dovremmo entrare nel primo

dizionario e richiamare i dati tramite la chiave "results", poi recuperare i dati contenuti

nella posizione 0 della lista, entrare nel nuovo dizionario e richiamare i dati tramite la

chiave "plate"

es:

>>> json["results"][0]["plate"]

'S11FRE'

# JSON è la variabile che contiene il JSON

Il codice sorgente

A titolo di chiarimento verranno di seguito analizzati in dettaglio due dei quattro codici

sorgente da noi realizzati per il funzionamento del sistema

4.1 Lettura OCR e transizione dati

Il seguente codice, scritto in Python, viene eseguito su Banana Pi e ha la funzione di leggere

i dati provenienti dall'ocr, confrontarli con il database, inviare il segnale di apertura ad

Arduino e scrivere un file di transizione informazioni.


17

1. import serial

2. import beanstalkc

3. import json

4. import os

5.

6. immx=0

7. immy=0

8. buffer=0

9. valstanga = 0

10.

11. open_alprd = "/home/bananapi/openalpr/src/build/alprd --config /etc/openalpr"

12. os.system("pkill alprd")

13. os.system(open_alprd)

14.

15. try:

16. ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)

17. except:

18. try:


20. except:

21. try:

22. ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

23. except:

24. pass

25.

26. beanstalk = beanstalkc.Connection(host='localhost', port=11300)

27. beanstalk.watch('alprd')

28.

29. while True:

30.

31. f = open('/home/bananapi/Desktop/Database.conf','r')

32. s=str(f.readlines())

33. dati=eval(s)

34.

35. job = beanstalk.reserve()

36. jobb = job.body

37. job.delete()

38. d = json.loads(jobb)

39.

40. time = str(d["processing_time_ms"])

41. targa = str(d["results"][0]["plate"])

42. x1 = str(d['results'][0]['coordinates'][0]['x'])

43. y1 = str(d['results'][0]['coordinates'][0]['y'])







50. immx = str(d['img_width'])

51. immy = str(d['img_height'])


18

52.

53.

54. for num in range(0,40):

55. try:

56. try:

57. number_lines = len(dati)

58. for i in range(0, number_lines):

59. diz1 = eval(dati[i])

60. targa_diz = diz1['targa']

61. if (str(d['results'][0]['candidates'][num]['plate']) ==

targa_diz):

62. try:

63. ser.write("1")

64. except:

65. pass

66. valstanga = 1

67. nome = diz1['nome']

68. print " Consento l'accesso! ", time," mS ", nome

69.

70. except:

71. pass

72.

73. except:

74. pass

75.

76. trasm = dict()

77. trasm["targa"]=nome

78. trasm["tempo"]=time

79. trasm["valstanga"]=valstanga

80. trasm["x1"]=x1

81. trasm["y1"]=y1

82. trasm["x2"]=x2

83. trasm["y2"]=y2

84. trasm["x3"]=x3

85. trasm["y3"]=y3

86. trasm["x4"]=x4

87. trasm["y4"]=y4

88. trasm["immx"]=immx

89. trasm["immy"]=immy

90.

91. f1 = open('/home/bananapi/Desktop/trasmissione.conf','w')

92. f1.write (str(trasm))

Commenti al codice:

1. import serial

2. import beanstalkc

3. import json

4. import os


19

Questa parte di codice è incaricata di importare le librerie necessarie alla corretta

esecuzione del programma.

Serial è la libreria che gestisce la comunicazione USB con Arduino, beanstalkc è necessario

al fine di leggere il "contenitore" di cui si è parlato nella sezione 3.3, json è la libreria che

decodifica i dati provenienti da beanstalkc ed infine os gestisce il controllo del terminale

della macchina (è possibile eseguire comandi su shell o terminale).

1. open_alprd = "/home/bananapi/openalpr/src/build/alprd --config /etc/openalpr"

2. os.system("pkill alprd")

3. os.system(open_alprd)

Ora viene assegnata alla variabile open_alprd una stringa (le stringhe in python vengono

contrassegnate con le virgolette) contenente il percorso dove è collocato il software OCR.

Con la seconda riga viene spedito il comando pkill alprd sul terminale delle macchina.

Questo comando interrompe eventuali processi del software ocr che erano già stati aperti

in precedenza (è necessario al fine di evitare che due processi di riconoscimento caratteri

siano eseguiti nello stesso momento).

La terza riga esegue il comando contenuto nella variabile open_alpr sul terminale della

macchina.

1. try:


3. except:

4. try:


6. except:

7. try:

8. ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

9. except:

10. pass

Viene ora aperta la comunicazione con Arduino.

E' importante inserire l'istruzione di connessione in una struttura try-except perché nel

caso in cui il tentativo di connessione fallisca (per esempio USB arduino non collegata) il

software non deve interrompersi per colpa dell'errore, ma deve procedere con tutti gli altri

comandi ignorando il problema.

E' inoltre importante fare dei tentativi di connessione su varie porte Usb visto che diversi

tipi di arduino possono utilizzare diversi tipi di driver.

Così se il primo ciclo try restituisce errore (o perché la USB non è collegata o perché i driver

sono errati) si passa al secondo try che tenta la connessione con altri driver.

I tentativi continuano fino all'ultimo except dove viene data l'istruzione di saltare il

passaggio di connessione e procedere con il restante codice.

La struttura della connessione è la seguente :


20

Quando si eseguono operazioni di lettura o scrittura relative alla connessione seriale si

utilizza la variabile "ser" (es: ser.read() significa "leggi i dati provenienti dalla

comunicazione").

'dev/ttyUSB' è il driver di Arduino (è come la COM in windows);

9600 è il bitrate in bit/sec;

timeout=1 è il tempo (s) dopo il quale, in caso di non risposta, si interrompono i tentativi.

1. beanstalk = beanstalkc.Connection(host='localhost', port=11300)

2. beanstalk.watch('alprd')

Apre il collegamento con il server "contenitore" dei dati provenienti dall'ocr.

Il server si trova sulla stessa macchina (localhost) e risponde alla porta 11300.

1. while True:

Tutte le istruzioni precedenti a questo comando vengono eseguite solamente all'avvio,

mentre quelle a seguire saranno eseguite a ciclo continuo.

1. f = open('/home/bananapi/Desktop/Database.conf','r')

2. s=str(f.readlines())

3. dati=eval(s)

Viene aperto il file contenete il database, situato nel direttorio

/home/bananapi/Desktop/Database.conf' in sola lettura (in questo caso non è necessaria la

scrittura se si devono fare solamente confronti tra le targhe lette ed il database).

Il file Database.conf viene poi letto e convertito in una lista (v. struttura lista sezione 3.3)

dove l'indice della lista è il numero della riga e l'oggetto è il contenuto in stringa della riga.

La struttura del database è:

{'targa':'RK755AJ', 'nome':'Matteo Dalponte', 'password':'17846', }

{'targa':'AA555AA', 'nome':'Mario Rossi', 'password':'95761', }

{'targa':'AB344CA', 'nome':'Ciao ', 'password':'98264', }

Dove tramite l'indice della lista si ricava la riga desiderata e poi, tramite la chiave del

dizionario, si ricava a piacere il numero di targa, il nome o la password.

1. job = beanstalk.reserve()

2. jobb = job.body

3. job.delete()

4. d = json.loads(jobb)

5.

6. time = str(d["processing_time_ms"])

7. targa = str(d["results"][0]["plate"])



21








16. immx = str(d['img_width'])

17. immy = str(d['img_height'])

A questo punto viene letto il "contenitore" con i dati inseriti dall'OCR e questi vengono

tradotti in codice JSON (v. sezione 3.3 per spiegazione)

La variabile d conterrà ora tutti i dati riportati nelle pagine 12 e 13, con l'unica differenza

che sotto la chiave candidates avremo 40 tentativi di riconoscimento con diverse

affidabilità (confidence).

Vengono poi estrapolati da JSON (contenuto nella variabile d) i dati del tempo di processing

dell'immagine della targa (time), il numero di targa con maggior probabilità (targa), gli

angoli della targa (necessari poi per contornare la targa nel video streaming), la risoluzione

sull'asse delle x della telecamera (immx) e quella sull'asse delle y (immy).

1. for num in range(0,40):

2. try:

3. try:

4. number_lines = len(dati)

5. for i in range(0, number_lines):

6. diz1 = eval(dati[i])

7. targa_diz = diz1['targa']

8. if (str(d['results'][0]['candidates'][num]['plate']) ==

targa_diz):

9. try:

10. ser.write("1")

11. except:

12. pass

13. valstanga = 1

14. nome = diz1['nome']

15. print " Consento l'accesso! ", time," mS ",

nome

16.

17.

18. except:

19. pass

20.

21. except:

22. pass

Ora tutti i 40 tentativi di riconoscimento prodotti dall' OCR vengono confrontati con tutte

le targhe contenute nel database (struttura Database a pag. 17).


22

Nel caso in cui vi sia corrispondenza vene inviato il comando di apertura ad Arduino

(ser.write("1")), viene portata ad un valore alto una variabile (ci servirà poi per colorare di

rosso o di verde il contorno della targa sul video in streaming) e ricavato dal database il

nome del proprietario del veicolo consentito.

1. trasm = dict()

2. trasm["targa"]=nome

3. trasm["tempo"]=time

4. trasm["valstanga"]=valstanga

5. trasm["x1"]=x1

6. trasm["y1"]=y1

7. trasm["x2"]=x2

8. trasm["y2"]=y2

9. trasm["x3"]=x3

10. trasm["y3"]=y3

11. trasm["x4"]=x4

12. trasm["y4"]=y4

13. trasm["immx"]=immx

14. trasm["immy"]=immy

15.

16. f1 = open('/home/bananapi/Desktop/trasmissione.conf','w')

17. f1.write (str(trasm))

Viene ora creato un dizionario (trasm) che conterrà tutti i dati significativi della lettura della

targa ( posizione nel video, nome del proprietario del veicolo, targa consentita o meno e

risoluzione della videocamera).

Infine viene scritto il tutto su un file denominato trasmissione.

Tale file verrà poi letto in FTP dal PC di controllo collegato tramite cavo ethernet.

4.2 GUI Visualizzazione streaming

Figura 10: interfaccia grafica GUI per la visualizzazione dello streaming


23

Il seguente codice viene eseguito sulla macchina (PC remoto) ed è una GUI (graphical user

interface) necessaria per visualizzare lo streaming proveniente dall'IP camera.

Il software ha inoltre il compito di delimitare la targa, in verde se è presente una

corrispondenza della targa con il database, in rosso se non è presente alcuna

corrispondenza (v figura 10).

Il codice è scritto in python ed è stato compilato in modo tale da creare un file eseguibile

(EXE) per macchina windows; in questo modo non è necessario che il computer che lo

esegue sia dotato di interprete python e di tutte le librerie di funzionamento.

La libreria principale per il funzionamento di tale codice è OpenCV, libreria orientata alla

computer vision.

E' importante spendere alcune parole per descrivere le notevoli potenzialità di tale libreria,

pensata inizialmente da Intel per testare le CPU in applicazioni intensive, come ad esempio

la gestione di immagini 3D, e poi rilasciata come libreria open source per la computer

vision.

OpenCV contiene moduli di elaborazione di immagini e video I / O, e più di 350 algoritmi di

gestione dati quali: filtri di immagine, calibrazione della telecamera, riconoscimento di

oggetti, analisi strutturale e molti altri.

1. import cv2

2. import urllib

3. import numpy as np

4. import ctypes

5. from ftplib import FTP

6. import time

7.

8. x1=0

9. x2=0

10. x3=0

11. x4=0

12. y1=0

13. y2=8

14. y3=0

15. y4=0

16. immx=0

17. immy=0

18. immx1=500

19. immy1=500

20. tempopresente=0

21. tempopassato=0

22. valstanga=0

23.

24.

25.

26. stream=urllib.urlopen('http://192.168.0.44:8080/video')

27. ftp = FTP('192.168.0.44', 'bananapi', 'bananapi', timeout=2)


24

28.

29.

30. bytes=''

31. while True:

32. tempopresente=time.time()

33. if (tempopresente-tempopassato)>0.2:

34. tempopassato=tempopresente

35.

36. try:

37. temp=open('temp.conf','w')

38. ftp.retrbinary('RETR /home/bananapi/Desktop/trasmissione.conf',

temp.writelines)

39. temp.close()

40. f = open('temp.conf','r')

41. trasm=eval(f.read())

42.

43. user32 = ctypes.windll.user32

44. Yval=int(user32.GetSystemMetrics(1)*0.66)

45. rapp_trasf=((user32.GetSystemMetrics(1)*0.66)/

46. (eval(trasm['immy'])))

47. Xval=int((eval(trasm['immx']))*rapp_trasf)

48.

49. targa=trasm['targa']

50. x1=int((eval(trasm['x1']))*rapp_trasf)

51. y1=int((eval(trasm['y1']))*rapp_trasf)







58. immx=int((eval(trasm['immx']))*rapp_trasf)

59. immy=int((eval(trasm['immy']))*rapp_trasf)

60. valstanga=(trasm['valstanga'])

61.

62. except:

63. pass

64.

65.

66. bytes+=stream.read(1024)

67. a = bytes.find('\xff\xd8')

68. b = bytes.find('\xff\xd9')

69. if a!=-1 and b!=-1:

70. jpg = bytes[a:b+2]

71. bytes= bytes[b+2:]

72. i = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.CV_LOAD_IMAGE_COLOR)

73.

74. ridimensiona=cv2.resize(i, (Xval,Yval), fx=5, fy=5)

75.

76. pts = np.array([[x1,y1],[x2,y2],[x3,y3],[x4,y4]], np.int32)

77.


25

78. if valstanga==0:

79. cv2.polylines(ridimensiona,[pts],True,(0,0,255),2)

80. else:


82.

83. cv2.putText(ridimensiona,targa, (x1,y1-5), cv2.FONT_HERSHEY_PLAIN,

1.2,(255,255,255),2)

84. cv2.putText(ridimensiona,"Q=Uscita", (0,20), cv2.FONT_HERSHEY_PLAIN,

1.2,(255,255,255),2)

85.

86.

87. cv2.imshow("Riconoscimento targhe",ridimensiona)

88.

89.

90. if cv2.waitKey(1) & 0xFF == ord('q'):

91. break

92.

93.

94. cv2.destroyAllWindows()

Commento al codice:

1. import cv2

2. import urllib

3. import numpy as np

4. import ctypes

5. from ftplib import FTP

6. import time

Vengono importate le librerie; open cv (cv2 ) e numpy per la gestione dei fotogrammi,

urllib per l'apertura dello streaming, ctypes per ottenere informazioni utili dal sistema

operativo quali per esempio la risoluzione dello schermo, ftplib per la lettura in remoto del

file di trasmissione (v sez. 4.1 pag 14) e time per la gestione del tempo.

1. stream=urllib.urlopen('http://192.168.0.44:8080/video')

2. ftp = FTP('192.168.0.44', 'bananapi', 'bananapi', timeout=2)

Apre il link al quale risponde il server MJPEG e inserisce nella variabile streaming tutti tutte

le istruzioni per la lettura del link.

Apre poi una connessione ftp criptata verso Banana Pi; a questo tentativo di connessione

risponderà il server e la comunicazione servirà per scambiare dati tra il server (Banana Pi) e

il PC di controllo.

1. while True:


26

2. tempopresente=time.time()

3. if (tempopresente-tempopassato)>0.2:

4. tempopassato=tempopresente

Nel ciclo infinito while True andiamo ora ad assegnare alla variabile tempopresente il

valore in secondi del tempo trascorso dall'accensione della macchina al momento in cui si

richiama la funzione time.time().

Ogni 0,2 secondi viene rieseguito il ciclo IF

Questo accorgimento è un sistema rudimentale, ma in questo caso efficace al fine di non

rallentare due processi che richiedono diverse velocità alla macchina.

Infatti la lettura tramite FTP del file trasmissione.conf è nettamente più lenta della lettura

e visualizzazione del flusso video MJPEG quindi, se la lettura FTP venisse fatta ad ogni ciclo

macchina la visualizzazione dello streaming risulterebbe a scatti e in ritardo rispetto alla

realtà.

Con questo accorgimento le lettura FTP viene eseguita solamente ogni 200 millisecondi,

mentre la gestione video viene fatta a ciclo continuo senza interruzioni.

1. try:

2. temp=open('temp.conf','w')

3. ftp.retrbinary('RETR /home/bananapi/Desktop/trasmissione.conf',

temp.writelines)

4. temp.close()

5. f = open('temp.conf','r')

6. trasm=eval(f.read())

Con le righe 2,3,4 viene trasferito il file trasmissione.conf, situato su Banana Pi, alla

macchina dove viene eseguito il seguente codice.

Il file appena creato viene letto, vengono estratti i dati, viene convertito il contenuto in

dizionario (da file di testo si ricavano solo stringhe) e assegnato alla variabile trasm.

Il seguente file è temporaneo visto che al ciclo successivo viene riscritto e riletto.

7. user32 = ctypes.windll.user32


9. rapp_trasf=((user32.GetSystemMetrics(1)*0.66)/(eval(trasm['immy'])))

10. Xval=int((eval(trasm['immx']))*rapp_trasf)

11.

12. targa=trasm['targa']









27


21. immx=int((eval(trasm['immx']))*rapp_trasf)

22. immy=int((eval(trasm['immy']))*rapp_trasf)

23. valstanga=(trasm['valstanga'])

24.

25. except:

26. pass

L'interfaccia grafica (GUI) e quindi anche il video streaming visualizzato devono avere delle

dimensioni tali da non essere troppo grandi per lo schermo del PC e allo stesso tempo

mantenere le stesse proporzioni del video inviato dalla telecamera per evitare di

deformare l'immagine.

Si è deciso di occupare 2/3 dello schermo in altezza per cui, una volta applicata questa

misura, la lunghezza della finestra dovrà variare in base al rapporto del video sorgente.


Con il seguente comando inseriamo nella variabile Yval il valore della dimensione in pixel

dello schermo in altezza moltiplicandolo per 2/3 (0,66)

28. rapp_trasf=((user32.GetSystemMetrics(1)*0.66)/(eval(trasm['immy'])))

Il valore di Yval viene ora diviso per l'altezza in pixel dell''immagine della telecamera che

avevamo ricavato dall'ocr su Banana Pi e poi inserito nel file trasmissione.conf.

In questo modo il rapporto tra le grandezze dello schermo e della telecamera costituisce un

rapporto di trasformazione che utilizzeremo per adattare la posizione del contorno targa

nel piano di visualizzazione.

1. bytes+=stream.read(1024)

2. a = bytes.find('\xff\xd8')

3. b = bytes.find('\xff\xd9')

4. if a!=-1 and b!=-1:

5. jpg = bytes[a:b+2]

6. bytes= bytes[b+2:]

7. i = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.CV_LOAD_IMAGE_COLOR)

8.

9. ridimensiona=cv2.resize(i, (Xval,Yval), fx=5, fy=5)

10.

11. pts = np.array([[x1,y1],[x2,y2],[x3,y3],[x4,y4]], np.int32)

12.

13. if valstanga==0:


15. else:


17.


28

18. cv2.putText(ridimensiona,targa, (x1,y1-5), cv2.FONT_HERSHEY_PLAIN,

1.2,(255,255,255),2)

19. cv2.putText(ridimensiona,"Q=Uscita", (0,20), cv2.FONT_HERSHEY_PLAIN,

1.2,(255,255,255),2)

20.

21.

22. cv2.imshow("Riconoscimento targhe",ridimensiona)

23.

24.

25. if cv2.waitKey(1) & 0xFF == ord('q'):

26. break

27.

28.

29. cv2.destroyAllWindows()

Vengono inseriti tutti i bit provenienti dalla lettura della pagina di streaming nella variabile

bytes, vengono selezionati solamente i bit che contengono il fotogramma del video e

vengono ricombinati per crearne un'immagine dalla funzione cv2.imdecode.

L'immagine viene poi ridimensionata con i criteri scelti e descritti nella pagina precedente

e viene creato un poligono che avrà come estremi i punti di limite della targa riportati

dall'OCR nel JSON (v sez. 3.3 pag. 13).

Questo poligono verrà colorato in rosso o in verde in base al valore della variabile valstanga

e, assieme al numero di targa o proprietario del veicolo, verrà poi stampato a monitor

sopra l'immagine proveniente dall'IP camera.


29

Sitografia

http://www.anpr.net/

http://www.police.uk/information-and-advice/automatic-number-plate-recognition/

http://en.wikipedia.org/wiki/Automatic_number_plate_recognition

http://www.raspberrypi.org

http://www.linux.it/linux

http://it.wikipedia.org/wiki/Software_libero

http://www.softwarelibero.it/

https://gnu.org/

http://it.wikipedia.org/wiki/MPEG-4

http://en.wikipedia.org/wiki/Motion_JPEG

https://github.com/openalpr/openalpr/wiki/OpenALPR-Design

http://www.python.it/doc/intro/

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

http://www.html.it/pag/15614/dizionari/

http://www.html.it/pag/15613/liste/

https://github.com/openalpr/openalpr/wiki/OpenALPR-Daemon-%28alprd%29

http://opencv.org/

Documents

Sistema di riconoscimento targhe · Matteo Dalponte Tesina di Maturità A.S: 2014/2015 7 Hardware e il software libero 2.1 Caratteristiche Hardware: Raspberry Pi è un computer delle