Maggio 2007
Indice
Indice 1
Listings 4
1 Introduzione 5
3 Sviluppo dell’applicativo 13
3.1 Obiettivi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 Librerie Intel OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2.1 Aree funzionali delle librerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2.2 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Control Flow del programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3.1 Back subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3.2 Predizione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3.3 HighGui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3.4 Scripting GNUPlot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5 Conclusioni 45
Riferimenti bibliografici 47
L’implementazione del software che ha fornito i risultati comparativi è stata effettuata nel linguaggio di programma-
zione C++ tramite le librerie per il computer vision OpenCV2 , sviluppate internamente ad Intel, ma rese pubblicamente
fruibili ed utilizzabili tramite una licenza GPL-compatibile; lo sviluppo del codice è stato effettuato sotto controllo
di versione Subversion (SVN), in hosting presso Google Code3 . Il software è stato reso pubblico sotto licenza libera
GNU GPL4 .
Grazie al sistema di controllo di versione è stato possibile sviluppare il software contemporaneamente sia sotto archi-
tettura Unix (nello specifico diverse distribuzioni di GNU/Linux) che sotto architettura Microsoft Windows, risultando
cosı̀ pienamente compatibile con entrambe.
Con questa relazione ci si prefigge l’obiettivo di ripercorrere il cammino fatto nello sviluppo dell’elaborato, iniziando
nel primo capitolo con una introduzione ai due metodi di tracking, con un breve approfondimento delle rispettive basi
matematiche per poi concludere focalizzando l’attenzione sulla specifica implementazione del modello utilizzato.
La descrizione passerà nel secondo capitolo ad affrontare lo sviluppo del software che ha reso possibile lo svilup-
po della comparazione, approfondendo i punti fondamentali delle librerie utilizzate per andare poi ad analizzare
dettagliatamente il control-flow del programma.
L’ultima sezione sarà invece dedicata allo studio dei risultati ottenuti, e fornirà i risultati più importanti di tutta la
serie di esperimenti che sono stati compiuti con il software ottenuto, riportandone grafici comparativi e schermate di
esecuzione.
1 MICC, http://www.micc.unifi.it/
2 Open Source Computer Vision Library http://www.intel.com/technology/computing/opencv/
3 http://code.google.com/p/video-tracker/
4 GNU General Public License http://www.gnu.org/licenses/gpl.html
Il filtro ha l’obiettivo di stimare lo stato x ∈ ℜn di un processo a tempo discreto governato dalla seguente equazione
alle differenze
dove
A è la matrice di transizione del modello, ed è applicata allo stato precedente xk−1 ; è quindi una matrice quadrata che
mette in relazione due vettori delle stesse dimensioni: lo stato al tempo k − 1 e lo stato al tempo k. Risulta la
responsabile dell’aggiornamento dello stato.
B è la matrice di controllo sull’input del sistema. É applicata al vettore di controllo uk−1 ∈ ℜl e mappa questo nella
dimensione dello stato x; è quindi una matrice rettangolare nxl.
wk ∈ ℜn è il rumore che affligge il processo. Si assume che sia descritto da una gaussiana a media 0 e covarianza
descritta dalla matrice Qk . Formalmente wk ∼ N(0, Qk ).
Al tempo k l’osservazione dello stato reale xk è effettuata tramite il vettore della misura z ∈ ℜm che è modellato da
zk = Hxk + vk (2)
dove
H è la matrice che mappa lo spazio dello stato reale nello spazio dello stato osservato e risulta per questo rettangolare,
di dimensione mxn.
Da notare che lo stato iniziale ed i vettori che descrivono la presenza di rumore negli stati successivi sono da
considerarsi mutualmente indipendenti.
Come detto in precedenza il filtro di Kalman è un estimatore ricorsivo: questo significa che il filtro applica la sua stima
dello stato del processo ed ottiene un feedback nella forma del vettore della misura, dal quale può aggiornare la sua
computazione.
Le equazioni del filtro sono raggruppabili in due macrocategorie: time-update, responsabili della proiezione nel tem-
po dello stato corrente per ottenere la stima a priori dello stato successivo (rappresentata dal vettore x̂k− ∈ ℜn ), e
measurement-update, responsabili dell’incorporazione della misura allo stato corrente nella stima a priori, ottenendo
cosı̀ la stima a posteriori (rappresentata dal vettore x̂k ∈ ℜn ).
Solitamente lo stadio relativo al time-update viene definito come predict, mentre quello relativo al measurement-update
come correct.
2.1.2 Predict
Le equazioni specifiche per il passo di predict, che proiettano lo stato e la covarianza dallo stato k − 1 allo stato k sono
dove A e B derivano dalla formula (1), considerando sempre la covarianza relativa a w come Q, mentre Pk− è una
matrice che rappresenta la covarianza sull’errore nella stima a priori e Pk è una matrice che rappresenta la covarianza
sull’errore nella stima a posteriori.
2.1.3 Correct
Le equazioni che invece formalizzano il passo di correct effettuano una stima sul guadagno del filtro tra l’osservazione
attuale e quella predetta (5), ottengono la stima a posteriori (equazione (6)) data la stima a priori effettuata nel passo
di update (3) e dall’osservazione dello stato reale, definita in 2; viene calcolata anche la covarianza sull’errore nella
stima a posteriori (7):
Pk = (1 − Kk H)Pk− (7)
L’esecuzione dell’algoritmo è direttamente dipendente dalla scelta che viene effettuata riguardo ai parametri di confi-
gurazione, in particolare dai valori dei componenti delle matrici Q ed R.
La matrice che tiene conto della covarianza dell’errore sulla misura, R, è generalmente misurata prima dell’applicazio-
ne del filtro. Misurare questa grandezza è possibile perchè si suppone di poter misurare il processo in ogni momento,
cosicchè possiamo avere anche delle misure “offline” con le quali possiamo affinare il calcolo.
La determinazione dei valori della matrice Q invece, è solitamente molto più complicata da ottenere, perchè non c’è
la possibilità di osservare direttamente il processo che il filtro sta stimando.
In entrambi i casi la tecnica solitamente utilizzata per effettuare la stima tramite il filtro di Kalman è di renderlo più
performante “sintonizzando” i valori di Q ed R e riapplicando il filtro, in modo da determinare empiricamente la
miglior configurazione.
Possiamo notare inoltre che quando nell’esecuzione le matrici P e Q sono costanti, anche la covarianza sull’errore
della stima Pk ed il guadagno di Kalman Kk si stabilizzano velocemente fino a rimanere costanti.
Figura 4: Esempio di applicazione del ConDensation per la rilevazione del contorno di una mano
Per quanto rigurda il nostro lavoro il Condensation ci interessa perchè risulta robusto rispetto a dati molto rumorosi
ed a cambiamenti di stato non lineari. La semplicità di questo permette di utilizzare per la descrizione approssimata
del moto dell’oggetto anche modelli dinamici non lineari. In modo particolare è quest’ultima caratteristica che lo
contraddistingue in modo netto con il filtro di Kalman, che viceversa raggiunge il massimo della sua efficienza in
ambiti lineari.
L’algoritmo utilizza un campionamento casuale e ordinato per modellare funzioni di densità di probabilità arbitraria-
mente complesse. Utilizza N campioni pesati per approssimare la curva che descrive la distribuzione dei dati.
Ciascun campione - sample - consiste dunque di uno stato e di un peso. Il peso è proporzionale alla probabilità che lo
stato del sample sia lo stato predetto dall’algoritmo.
Chiamiamo con H il vettore dei samples {→
t
−s (t), →
1
−
s (t), ..., →
1 N
−
s (t)} all’istante t. (ipotesi)
→
−
si (t) = {→
−
xi (t), p(xi (t))} (8)
→
−
xi (t) è la posizione stimata per il sample i all’istante t.
p(→−
x (t)) è la probabilità associata alla posizione →
i
−x (t) che caratterizza il sample i
i
Inizializzazione - passo 0
Al primo passo dell’algoritmo si inizializza tutti i samples:
• Ciascuna posizione può essere scelta in modo casuale secondo una distibuzione uniforme.
• La probabilità associata a ciascun sample al primo passo è invece distribuita secondo una gaussiana standard
centrata nel valore medio tra il valore massimo e il valore minimo assumibile per la posizione dell’oggetto e la
relativa varianza.
Esecuzione - passo t
Il sample →
−
si (t) con probabilità maggiore è la predizione per il Condensation.
Per passare dal vettore di stato Ht al successivo Ht+1 si eseguono i seguenti passi:
pi (→
−
xi (t + 1)) = p(→
−
xi (t)k→
−z (t)) (10)
• x l’ascissa della posizione sul piano cartesiano come rappresentato dalla figura 8.
• y l’ordinata della posizione sul piano cartesiano come rappresentato dalla figura 8.
• vx la velocità della componente orizzontale.
• vy a velocità della componente verticale.
Responsabile della mappatura del suddetto stato al tempo k − 1 verso lo stato al tempo k è la matrice A, matrice di
transizione del modello, che risulta essere quadrata (4x4) in quanto mantiene la relazione tra due vettori delle stesse
dimensioni.
1 0 ∆t 0
0 1 0 ∆t
A= 0 0 1 0
(12)
0 0 0 1
dove i parametri al suo interno mappano la transizione di ogni componente: rispettivamente le posizioni passate
vengono sovrascritte da quelle nuove e lo stato aggiornato dall’equazione x + ∆t · vx , per ogni riga della matrice.
Il vettore B, moltiplicato per il vettore dei controlli esterni u, comporta una modifica al sistema solo sull’ultima
componente (velocità verticale).
Nella realizzazione si è impostato il parametro g e ∆t pari ad 1, per tracciare il moto su un piano, in quanto non si
avevano forze esterne, che potessero condizionare il sistema.
0
0
B=
0
(13)
g∆t
L’ultima componente della relazione 1 è la modellazione vettoriale del rumore, rappresentata come visto tramite
il vettore w. Assumendo il rumore come gaussiano, risulta di interesse la descrizione della matrice, che modella la
covarianza di questo, rappresentata da Q, riguardo all’importanza che riveste nella sintonizzazione del filtro di Kalman,
come si è ampiamente spiegato nella sezione 4 Esperimenti .
0.01 0 0 0
0 0.01 0 0
Q=
0
(14)
0 0.01 0
0 0 0 0.01
Le ultime due matrici che compaiono nelle equazioni del modello riguardano la misura, cioè i valore ottenuti dal
background subtraction.
La prima ( 15 ) pesa il valore dell’osservazione, effettuata dal background subtraction, per correggere la predizione
del filtro di kalman.
1 0 0 0
H= (15)
0 1 0 0
Il nostro modello viene inserito nell’applicazione combinando l’uso del calcolo matriciale fornito dalle OpenCv con
il parsing di un file testuale data.txt, che risulta essere l’input dei dati dell’ applicazione.
É bene sottolineare che questo modello è usato ovviamente il kalman, ma soprattutto la matrice A di transizione dello
stato è riutilizzata anche nell’algoritmo ConDensation come modello dinamico.
Per maggior approfondimento sullo sviluppo, costruzione e progettazione del software si rimanda alla sezione 3.
3.1 Obiettivi
L’ obiettivo del software è quello di realizzare un applicativo che esegua model based tracking (vedi sezione 2) sulla
base di un video passatogli come ingresso. Più nel dettaglio l’applicazione esegue il tracciamento tramite il filtro di
Kalman [1] e il ConDensation [3], in maniera tale da poter confrontare le prestazioni dell’ uno e dell’altro.
Altri requisiti funzionali sono quelli di:
• fare scegliere all’utente l’oggetto da tracciare in caso di tracking multiplo: in questo caso il software si ferma sul
primo frame del video, dando possibilità di scegliere l’oggetto di cui si vuol fare il tracciamento. Per migliorare
la selezione di un oggetto, vengono evidenziati dei puntini gialli in corrispondenza dei blob identificato. Vedi
figura 6
• tracciare a video l’andamento dei due algoritmi, evidenziandoli con colori differenti; visualizzare un’ ellissi per
ogni algoritmo che indichi la varianza del vettore di stato per quel tipo di tracking.
• fornire un output razionalizzato su terminale e su filesystem per verificare rispettivamente la corretta esecuzione
degli algoritmi e per avere un riscontro finale sulle performance e l’accuratezza di ognuno. Successivamente
parsare i suddetti file per una rappresentazione grafica dell’accuratezza dei due metodi di tracking.
• progettare e realizzare l’applicazione in maniera tale che possa essere compilata ed eseguite su piattaforme
diverse.
Figura 6: Esempio di scelta tra due blob su tracking multiplo: l’utente ha la possibilità di sccegliere su quale blob effet-
tuare il tracciamento semplicemente cliccando vicino ad uno dei punti gialli. Il Sistema automaticamente selezionerà
il blob più vicino attraverso il calcolo della distanza euclidea
É bene sottolineare che il video in ingresso possiede delle restrizioni; infatti affinchè il background subtraction lavori
in maniera ottima, è necessario che il video:
Qualsiasi video che rispetti questi tre vincoli è considerato non solo adeguato, ma ottimale per effettuare il tracking
con la nostra applicazione.
Le librerie OpenCV nascono appunto a questo scopo; lo sviluppo prende le mossa da un gruppo di ricerca sponsoriz-
zato da Intel. E’ infatti parzialmente basata sulla Intel Image Processing Library (IPL): tale prodotto è oggi integrato
nella libreria commerciale IIPP (Intel Integrated Performance Primitives), con cui conserva piena compatibilità e verso
la quale rende disponibili un completo ventaglio di funzioni più specifiche.
Tra i punti di forza sottolineiamo inoltre la politica di licenza utilizzata, in stile BSD e definita nella “Intel License
Agreement For Open Source Computer Vision Library”, completamente compatibile con la licenza GPL. A grandi
linee questo permette una libera ridistribuzione sia in forma sorgente che binaria, anche all’interno di prodotti com-
merciali, a condizione di mantenere le note di copyright e di non utilizzare il nome Intel a scopo promozionale di
prodotti derivati.
Inoltre un’ altra potenzialità offerta è la caratteristica di essere cross-platform: cioè possono essere compilate e usate
sia sotto sistema operativo Microsft Windows che GNU/Linux. Questa caratteristica le rende molto appetibili per i
requisiti di portabilià che ci eravamo prefissi di raggiungere.
Da notare che le librerie sono scritte in linguaggio C e non fanno uso quindi di un linguaggio orientato agli oggetti.
Si vuol chiarire subito un fatto che può essere causa di equivoci: con il termine “libreria grafica” infatti si identificano
genericamente almeno tre famiglie di librerie, i cui scopi sono sostanzialmente differenti:
1. I Toolkit, ovvero librerie di primitive per la creazione di oggetti grafici di interfaccia (finestre, icone, bottoni,ecc).
Parzialemente ricoperto in OpenCV dalle HighGui.
2. Librerie di rendering e multimedia, come DirectX e OpenGL, orientate alla massima performance nella creazio-
ne di effetti poligonali o vettoriali. L’utilizzo più comune è teso all’ottenimento di elevate prestazioni grafiche
sfruttate ad esempio nei videogiochi o nelle applicazioni multimediali.
Le OpenCV, pur includendo alcune funzionalità tipiche di ciascuna delle famiglie citate 5 , non fanno parte di nessuno
di questi gruppi. L’utilizzo primario è infatti quello collegato alla visione artificiale, il cui problema principale, come
già visto, è quello di estrarre da immagini/video dati significativi, trattabili in modo automatico. Tale campo di studio
trova le sue applicazioni più comuni nella robotica, nei sistemi di videosorveglianza evoluti e nei sistemi di monito-
raggio e sicurezza, oltre che in ogni sistema di archiviazione automatica di informazioni visive.
La libreria include attualmente più di 300 funzioni, che coprono le più svariate esigenze di trattamento di immagini,
comprese funzioni matematiche ottimizzate (elevamento a potenza, logaritmi, conversioni cartesiane-polari, ecc.) ed
un completo pacchetto di algebra matriciale, sviluppato funzionalmente al resto del sistema.
La principale categoria di uso rimane comunque il processing di tipo real-time su immagini e video.
Una panoramica generale delle librerie comprende questi aspetti della computer vision:
2. Object Identification
5. Motion Tracking
3.2.2 Riferimenti
Come molti progetti opensource in maturazione 6 è stata carente la parte che riguarda la documentazione. Nonostante
la presenza di un colosso alle spalle e di una struttura basata sul modello wiki, la documentazione ufficiale in pdf e
html, anche se facilmente fruibile, non è stata sufficiente per colmare le lacune iniziali. Per questo motivo è stato
effettuato un grosso lavoro di studio per capire il funzionamento del toolkit OpenCv, che spesso è terminato con la
ricerca di documentazione in website asiatici, dove sembra che queste librerie siano molto gradite.
Alcuni riferimenti importanti per OpenCV:
1. Background Subtraction
2. Aggiornamento di Kalman e Condensation
3. Rappresentazione dei risultati
void execute ( f i l e ) {
video = captureFromAvi ( f i l e )
initBackgroundSubtraction ( video )
f o r ( i n t f r = 1 ; f r a m e = c a p t u r e N e x t F r a m e ( v i d e o ) , f r ++ ) {
i f ( f r a m e == FIRST FRAME ) {
initKalman ( blob ) ;
i n i t C o n d e n s a t i o n ( blob ) ;
}
else{
b l o b = g e t B l o b ( Frame ) ;
updateKalman ( blob ) ;
updateCondensation ( blob ) ;
}
}
}
L’idea di base del Background Subtraction è quella di identificare il livello di background per un determinato video,
segmentando ogni frame in altri due frames chiamati rispettivamente:
• Foreground Mask
• Background Mask
7 Per meglio spiegare gli effetti del metodo online si suppone di effettuare fuori dal ciclo il background subtraction su tutto il video e una volta
finito questo passare all’analisi. Cosı̀ facendo si appesantisce tutto l’algoritmo di calcolo e si fornisce una lunga e inutile attesa lato utente
Distribuzione Unimodale Il più semplice modello assume che l’intensità del valore di un pixel può essere modellata
da una distribuzione unimodale, come una distribuzione Gaussiana del tipo N(µ, σ 2 )
Mixture of Gaussian MoG Il modello MoG generalizzato viene di solito usato per modelli abbastanza complessi,
non statici con molteplici background. Questo tipo di modellazione è di tipo statistico e online. L’idea è quella
di modellare ogni pixel in un processo di funzioni gaussiane, successivamente eseguire l’apprendimento online
e rilevare il foreground passo passo sulla base dell’intensità del valore di grigio di ogni pixel. In particolare un
pixel sarà classificato come un pixel di foreground se la distribuzione a lui associata ha peso sufficientemente
basso e varianza alta, viceversa verrà classificato come background pixel.
Tecniche Non Parametriche Si stima la funziona di densità di probabilità per ogni pixel preso dai tanti campioni,
usando una tecnica di stima sulla densità di probabilità.
Approccio basato su regioni o frame É una tecnica basata su pixel, che assume che le serie di temi dell’osservazione
è indipendente per ogni pixel. L’approccio ad alto livello è eseguito segmentando un’immagine in una regione
o ridefinendo un sottolivello di classificazione ottenuto su ogni pixel.
Nell’applicativo sarà usato il modello di Mixture of Gaussians (MoG), sia perchè si vuole coprire anche video di
una certa complessità e sia perchè le librerie offrono un buon supporto per questo modello. In particolare nel listato
sottostate è visualizzato l’uso di esse nel file addetto al background subtraction.
/ / / The f u n c t i o n t h a t i n i t t h e B a c k g r o u n d s u b t r a c t i o n w i t h G a u s s i a n model
/∗ ∗
∗ \ param bgmodel t h e model s t r u c u t r e
∗ \ param t m p f r a m e t h e t e m p o r a r y f r a m e
∗ \ param bgmodel paramMog t h e p a r a m e t e r s
∗/
v o i d i n i t B a c k g r o u n d M o d e l ( CvBGStatModel ∗∗ bgmodel , I p l I m a g e ∗ t m p f r a m e ,
CvGaussBGStatModelParams ∗ paramMoG ) {
/ / I n i t o f t h e params
paramMoG−>w i n s i z e = 2 0 0 ;
paramMoG−>n g a u s s = 3
paramMoG−>b g t h r e s h o l d = 0 . 1 ;
paramMoG−>s t d t h r e s h o l d = 5 ;
paramMoG−>minArea = 2 0 0 . f ;
paramMoG−>w e i g h t i n i t = 0 . 0 1 ;
paramMoG−> v a r i a n c e i n i t = 3 0 ;
/ / I n i t o f t h e model
∗ bgmodel = c v C r e a t e G a u s s i a n B G M o d e l ( t m p f r a m e , paramMoG ) ;
/ / U p d a t i n g t h e G a u s s i a n Model
c vU pd a te BG S ta tM o de l ( t m p f r a m e , b g m o d e l ) ;
/ / r e t u r i n g th e binary background
r e t u r n bg model−>f o r e g r o u n d ;
}
Dalla prima funzione si nota come vengano inizializzati i parametri su cui poi sarà costruito il modello di previsione
del foreground; in particolare si nota che:
Per il resto del codice è giusto notare che ogni volta che si processa un nuovo frame anche l’algoritmo viene aggiornato
su quel frame.
Figura 7: Esempio di background subtraction graduale. Viene segnalato nella prima finestra quello che è il foreground
del video e in seguito nella seconda l’effetto del background subtraction che mette in rilievo il blob bianco rilevato
sullo sfondo. Ovviamente come si vede nella figura se l’algoritmo non lavora in maniera ottimale è possibile ottenere
blob che non esistono nell’immagine di partenza.
La parte di predizione dei dei due algoritmi è descritta nei file kalman.cpp e condensation.cpp ed è sufficien-
temente semplice, grazie all’astrazione fornita dalle librerie OpenCV.
Nel listato sottostante è rappresentato il passo di predizione del filtro di Kalman, già inizializzato , che effettua in
sequenza:
1. La predizione (Predict - Time Update) del nuovo punto di stato sulla base del modello dinamico da noi descritto,
cioè sulla base delle matrici A,B ed u.
2. La correzione (Correct - Measurament Update) sul nuovo punto sulla base della misura ottenuta dalla ground
truth con il metodo del Background Subtraction. É da notare come nel vettore measurement vengono proprio
inserite le componenti ottenute dall’osservazione.
/ / / The f u n c t i o n t h a t w i l l u p d a t e t h e kalman s t r u c t u r e w i t h t h e d a t a c o l l e c t e d i n
e x t r a c t B l o b . i t w i l l p r o v i d e t o do t h e p r e d i c t and t h e c o r r e c t kalamn ’ s s t e p .
/∗ ∗
∗ \ param kalman t h e p o i n t e r t o t h e kalman s t r u c t u r e
∗ \ param s t r u c t c o o r d i n a t e t h e s t r u c t i n w h i c h a r e t h e m e a s u r e m e n t c o o r d i n a t e . ( z k )
∗/
f l o a t ∗ u p d a t e K a l m a n ( CvKalman ∗ kalman , c o o r d c o o r d ) {
i n t Meanx , Meany ;
CvMat∗ m e a s u r e m e n t = c v C r e a t e M a t ( 2 , 1 , CV 32FC1 ) ;
Meanx = ( i n t ) c o o r d . cX ;
Meany = ( i n t ) c o o r d . cY ;
cvmSet ( measurement , 0 , 0 , Meanx ) ;
cvmSet ( measurement , 1 , 0 , Meany ) ;
CvMat∗ u = c v C r e a t e M a t ( 1 , 1 , CV 32FC1 ) ;
u−>d a t a . f l [ 0 ] = 1 ;
/ / Kalman P r e d i c t
c o n s t CvMat∗ p r e d i c t = c v K a l m a n P r e d i c t ( kalman , u ) ;
/ / Kalman C o r r e c t
c o n s t CvMat∗ c o r r e c t = c v K a l m a n C o r r e c t ( kalman , m e a s u r e m e n t ) ;
r e t u r n c o r r e c t −>d a t a . f l ;
Quanto detto è stato già ampiamente dimostrato nella sezione 2.1 e in particolare nella figura 2; a livello di codice
si nota che l’aggiornamento di Kalman è effettuato richiamando le funzioni cvKalmanPredict(kalman,u) e
cvKalmanCorrect(kalman, measurement).
Infine è bene sottolineare che la predizione, come accordato nella 2.3, è rappresentata da un vettore di due componenti,
dove la prima rappresenta l’ascissa e la seconda l’ordinata nel piano del Video, che hanno come centro (0,0) il pixel
in alto a sinistra.
1. l’aggiornamento delle varie probabilità per ogni samples inizializzato sulla base dell’osservazione ottenuta dalla
ground truth. Eseguito dall funzione updateProcessProbDens
2. la scelta del sample a probabilità maggiore, operazione delegata dalla funzione presente in OpenCv dal nome
cvConDensUpdateByTime
i n t DP = i n d e x M a t [0]−> c o l s ; / / ! number o f s t a t e v e c t o r d i m e n s i o n s ∗ /
i n t MP = i n d e x M a t [2]−> rows ; / / ! number o f m e a s u r e m e n t v e c t o r d i m e n s i o n s ∗ /
...
f o r ( i n t i = 0 ; i <DP∗DP ; i ++) {
ConDens−>DynamMatr [ i ] = i n d e x M a t [0]−> d a t a . f l [ i ] ;
}
CvRNG r n g s t a t e = cvRNG ( 0 x f f f f f f f f ) ;
r e t u r n ConDens ;
}
c o o r d u p d a t e C o n d e n s a t i o n ( C v C on D e ns a t io n ∗ ConDens , c o o r d Measurement , f l o a t ∗
stdDX ptr , f l o a t ∗ stdDY ptr ) {
coord p r e d i c t i o n ;
u p d a t e P r o c e s s P r o b D e n s ( ConDens , Measurement , s t d D X p t r , s t d D Y p t r ) ;
cvConDensUpdateByTime ( ConDens ) ;
p r e d i c t i o n . s e t ( ConDens−>S t a t e [ 0 ] , ConDens−>S t a t e [ 1 ] ) ;
return p r e d i c t i o n ;
}
Come accennato nella sezione 3.2.1, le librerie OpenCv offrono anche un parte di toolkit per realizzare semplici widget
grafici in cui poter visualizzare immagini o video, oppure semplici form per incrementare/decrementare il tuning di
determinati parametri. É bene sottolineare che esse permettono anche la gestione degli eventi lato utente; per esempio
è possibile catturare eventuali click del mouse. Queste widget risultano molto utile ovviamente se si vuole che l’utente
interagisca in maniera attiva con il software: nel nostro caso si è usato una semplice NamedWindow, fornita da questo
toolkit, in cui visualizzare il video con i relativi tracciamenti; in più si è creato un gestore di eventi per catturare
eventuali click del mouse che permettono all’utente di selezionare il blob da tracciare in caso di tracking multiplo. Il
codice seguente mostra l’uso delle HighGui per realizzare quanto detto:
/ / ! C r e a t e t h e window
cvNamedWindow ( ” v i d e o −t r a c k e r ” , 1 ) ;
...
i f ( f r a m e == FIRSTFRAME ) {
c v S e t M o u s e C a l l b a c k ( ” v i d e o −t r a c k e r ” , on mouse , 0 ) ;
...
...
/ / ! D i s p l a y t h e temp f r a m e i n t h e window
cvShowImage ( ” v i d e o −t r a c k e r ” , t m p f r a m e ) ;
...
/ / ! L e f t C l i c k Mouse E v e n t F u n c t i o n s
v o i d on mouse ( i n t e v e n t , i n t x , i n t y , i n t f l a g s , v o i d ∗ param ) {
switch ( event ) {
c a s e CV EVENT LBUTTONDOWN: {
CLICK [ 0 ] = x ;
CLICK [ 1 ] = y ;
} break ;
}
}
Oltre lo sviluppo software, si è anche riusciti a salvare in output i risultati su file testuali, in modo tale da effettuare
una successiva lettura con un qualsiasi visualizzatore di grafici com Excel o Matlab. I file prodotti contengono le
coordinate, prese frame per frame, del blob stimato con il background subtraction e dei due tracciamenti. Inoltre è
anche generato un file riassuntivo con i princiapli coefficieni di rendimento dei due metodi di tracking, quali varianza
media e distanza media tra blob osservato e misurato.
Fatto ciò si è scelto il sistema libero GNUPlot per interpretare e dare una rappresentazione grafica automatizzata dei
dati raccolti, con la possibilità di creare anche immagini su hardisk al volo dei grafici. Si è infatti prodotto uno scritp
bash, (fruibile anche sui sistemi Windows con GNUPlot) ,che automatizza il processing dell’output.
Lo script risulta il seguente:
Listing 6: Script bash che invoca GNUPlot con i vari file di configurazione - gplot.sh
# ! / bin / bash
Listing 7: Un esempio di file di configurazione dello scritp che visualizza il grafico - plot-window
# gnuplot scripting
set grid
Per ciascun video abbiamo osservato/confrontato il comportamento dei due filtri al variare di alcuni parametri quali:
• covarianza relativa al rumore del processo studiato (Q) (stabilisce la tolleranza consentita alla predizione del
filtro di Kalman)
– la posizione dell’oggetto
– la posizione predetta dal filtro di Kalman
– la posizione predetta dal Condensation
• Il secondo rappresenta per ogni campionamento di quanto rispettivamente ciascuna predizione si discosta dalla
posizione reale dell’oggetto.
Inoltre per ogni test viene dato il valore medio della distanza (in pixels) tra posizione predetta e posizione reale, sia per
il filtro di Kalman (δ̄K ) che per il Condensation (δ̄C ), oltre al valore della varianza media per il Condensation (σx , σy ).
• fps: 25.00
• durata: 50.4 s
Si tratta di una ripresa trasversale dall’alto di un automobilina radiocomandata. In questa scena i punti di occlusione
sono due: una scatola al centro della scena e un ostacolo sulla sinistra. La macchina non subisce repentine accele-
razioni o decelerazioni, in generale ruota attorno alla scatola centrale e riamane nascosta dietro questa per un po’.
L’automobilina non esce mai dalla scena.
Statistiche:
• δ̄K : 105
• δ̄C : 18
• (σx , σy ): (112,81)
Appare evidente che con queste impostazioni il filtro di Kalman non è in grado di mantenere traccia correttamente
dell’oggetto, poichè più di una misurazione è persa a causa dell’occlusione. L’area di tolleranza per Kalman non
è sufficiente. Tuttavia non appena l’oggetto ripassa vicino a dove Kalman si è fermato, questo ricomincia ad essere
tracciato correttamente. Differentemente il Condenstaion non perde mai l’oggetto, ma la stima del moto è decisamente
meno precisa.
Statistiche:
• δ̄K : 0
• δ̄C : 18
• (σx , σy ): (112,81)
Allargando l’area di confidenza per Kalman l’oggetto non viene mai perso e il tracciamento risulta pressochè perfetto.
Il comportamrento in questo caso è evidentemente migliore del Condesation. Purtroppo un’area di confidenza troppo
ampia potrebbe in alcune circostanze far perdere di validità al tracciamento.
Statistiche:
• δ̄K : 105
• δ̄C : 17
• (σx , σy ): (109,81)
Con questo test cominciamo a verificare il comportamento del Condensation alla variazione del numero di samples.
E’ immediato osservare come aumentando il numero di samples da 1000 a 5000 questo non porti in media nessun
significativo miglioramento.
Statistiche:
• δ̄K : 105
• δ̄C : 24
• (σx , σy ): (140,92)
Di contro con questo test si nota come passando da 1000 a 100 samples invece il risultato sia notevolemente diverso.
La stima del moto come si vede dal grafico è notevolemente peggiore nel secondo caso. Fortunatamente ha anche
poco senso limitare cosı̀ tanto il numero di samples, mentre un numero molto alto di samples per noi non comporta
nessun particolare svantaggio.
Statistiche:
• δ̄K : 105
• δ̄C : 55
• (σx , σy ): (195,112)
Abbiamo proseguito nel diminuire il numero di Samples per il Condensation passando a 10, il confronto tra il caso
in cui i samples erano 1000 è autoesplicativo: il risultato è notevolemente peggiore. Come ci si poteva aspettare in
condizioni estreme di lavoro le previsioni sono decisamente inattendibili.
• fps: 10.00
• durata: 59 s
Si tratta di una ripresa trasversale dall’alto. L’oggetto in movimento è un’automobilina radiocomandata che si muove
su un’area delimitata da un tappeto. Il moto dell’automobilina subisce repentine accelerazioni e decelerazioni. Non ci
sono oggetti occludenti, ma l’automobilina entra ed esce totalmente o parzialmente più di una volta dalla scena.
Statistiche:
• δ̄K : 53
• δ̄C : 22
• (σx , σy ): (53,22)
La macchinina si sposta in modo molto rapido. Kalman si comporta in modo egregio fintanto che l’oggetto si trova
nell’inquadratura e che l’accelerazione della macchina non è tale da far uscire l’oggetto dall’area di previsione. Il
Condensation mantiene un buon comportamento anche se mai perfetto.
Statistiche:
• δ̄K : 137
• δ̄C : 31
• (σx , σy ): (56,40)
Come prevedibile la rapidità di moto di questo oggetto mal si concilia una misurazione effettuata ad intervalli ampi.
Entrambi i filtri si comportano in modo non proprio ottimale, in particolare Kalman perde quasi immediatamente
l’oggetto.
Statistiche:
• δ̄K : 32
• δ̄C : 15
• (σx , σy ): (55,41)
La situazione decisamente migliora se invece campioniamo ogni 2 frames. Kalman fintato che non perde l’oggetto si
comporta meglio del Condensation, in media però il Condensation risulta migliore.
Statistiche:
• δ̄K : 0
• δ̄C : 8
• (σx , σy ): (55,41)
Ingrandendo l’area di tolleranza per Kalman e prendendo la misura ogni frame Kalman traccia perfettamente il moto
dell’oggetto e anche il Condensation migliora il proprio comportamento. Questa è una situazione ottimale, però
decisamente poco realistica. Sono risultati che possiamo ottenere solo perchè stiamo tracciando il moto di un oggetto
del quale conosciamo tutto dettagliatamente (Video Stream).
Statistiche:
• δ̄K : 0
• δ̄C : 8
• (σx , σy ): (55,41)
Campionando ogni frame, anche diminuendo l’area dell’ellisse di tolleranza per Kalman i risultati non cambiano.
• fps: 30.00
• durata: 33 s
Anche in questo caso il video è di un’automobilina radiocomadata ripresa dall’alto trasversalmente. A differenza che
negli altri video non ci sono oggetti occludenti e il moto è piuttosto uniforme. L’automobilina, però, entra ed esce
dalla scena più di una volta.
Statistiche:
• δ̄K : 323
• δ̄C : 23
• (σx , σy ): (111,83)
In questo test si hanno i risultati più comuni: se l’oggetto scompare dalle scena e riappare in punti molto distanti da
dove è scomparso il filtro di Kalman lo perde, ma quando l’oggetto è individuato correttamente Kalman è migliore del
Condensation. Tuttavia in media il Condensation è molto più preciso nella predizione.
Statistiche:
• δ̄K : 209
• δ̄C : 52
• (σx , σy ): (114,83)
Il video in questione si presta ad un tracciamento effettuato ad intervalli anche ampi poichè non ci sono brusche
accelerazioni o frenate. Il problema principale sul filtro di Kalman resta che perde l’oggetto se scompare ed è perciò
evidente la necessità di incrementare l’area di tolleranza per migliorare le prestazioni del filtro.
Statistiche:
• δ̄K : 252
• δ̄C : 40
• (σx , σy ): (113,82)
Anche riducendo in numero di frames di campionamento la situazione non cambia molto, anzi per un caso crediamo
dovuto alla natura del video stesso la situazione addirittura peggiora per il filtro di Kalman. Decidiamo perciò di
togliere il controllo sulla correttezza del rilevamento da parte di Kalman e ci poniamo come unico obiettivo quello di
farlo lavorare in condizioni di minima tolleranza sull’errore.
Statistiche:
• δ̄K : 5
• δ̄C : 37
• (σx , σy ): (113,82)
Togliendo il controllo sulla correttezza della predizione da parte di Kalman, se l’oggetto scompare siamo comuque
in grado di tracciarlo (il filtro di Kalman lo “insegue”). In media Kalman sbaglia pochissimo, il tracciamento è
quasi perfetto. L’obiettivo è ora quello di metterci in una situazione ipotetica in cui Kalman si comporta peggio del
Condensation.
Statistiche:
• δ̄K : 8
• δ̄C : 37
• (σx , σy ): (113,82)
Riduciamo l’errore consentito sulla predizione, l’ellisse di tolleranza si riduce imponendo a Kalma di sbagliare il meno
possibile. In questo test i risultati ottenuti non si discostano molto da quelli precedenti, l’oggetto è sempre tracciato
ottimamente dal filtro di Kalman.
Statistiche:
• δ̄K : 66
• δ̄C : 43
• (σx , σy ): (114,82)
Come previsto il filtro di Kalman comincia finalmente a peggiorare il proprio comportamento anche se in media è
sempre migliore dell’altro.
Statistiche:
• δ̄K : 179
• δ̄C : 43
• (σx , σy ): (114,83)
In questo test Kalman non riesce più a tracciare correttamente l’oggetto. Appare qui evidente come alcune zone si
dimostrino particolarmente critiche per il filtro di Kalman.
Abbiamo variato anche la frequenza di campionamento. Qui il comportamento di Kalman è migliore rispetto al test
precedente ed è più chiaro come Kalman si trovi in difficoltà soprattutto nel tracciare zone di non linearità del moto
dell’oggetto. (smoothness)
Statistiche:
• δ̄K : 22
• δ̄C : 8
• (σx , σy ): (111,85)
• risultati ottimali anche con video complessi da elaborare rispetto a metodi più semplici.
• discreta efficienza, nonstante il metodo sia complesso, garantita anche dall’alto livello con cui viene implemen-
tato in OpenCV.
Come già accennato inizialmente, nonostante la parte più corposa e importante dell’elaborato sia quella appena descrit-
ta, questa risulta avere un senso effettivo solamente se analizzata con lo scopo di trarne risultati descrittivi, obiettivo
primo di tutto il lavoro. L’analisi dettagliata di questi è stata approfonditamente documentata nella sezione 4, dalla
quale possono essere evinti i dati più significativi, in modo da rendere chiaro quale sia il risultato raggiunto da questo
lavoro.
I risultati forniti in questa relazione sono stati catalogati, prima selezionando i video che maggiormente riuscissero ad
evidenziare i punti di forza dell’uno e dell’altro metodo, quindi per ogni video sono stati presentati i risultati relativi
alla variazione di alcuni parametri determinanti tuning.
I parametri che sono stati variati sono la frequenza di tracking, ovvero il numero di frame che intercorrono tra due
consecutive applicazioni dell’algoritmo, la tolleranza consentita alla predizione dell’algoritmo di Kalman, ed il numero
di samples che vengono utilizzati per il ConDensation. Il tuning su questi parametri ci ha consentito di forzare l’utilizzo
dei due algoritmi in condizioni normali ma soprattutto nelle condizioni ottimali solo di uno dei due algoritmi alla volta,
in modo da studiare la risposta reciproca in questa stimolazione.
Sicuramente non è possibile stabilire con certezza quale dei due algoritmi risulti essere aprioristicamente il migliore, in
8 Un possibile sviluppo futuro potrebbe essere la creazione di un form scritto in HighGui per l’inizializzazione dei suddetti parametri all’avvio
del software
9 La pagina del progetto è http://code.google.com/p/video-tracker/ mentre per ottenere il materiale è sufficiente il comando “svn checkout
http://video-tracker.googlecode.com/svn/trunk/ video-tracker”
[2] M. Isard and A. Blake, “Condensation - conditional density propagation for visual tracking,” Int. J. Comput.
Vision, vol. 29, no. 1, pp. 5–28, 1998.
[3] T. Petrie, “Tracking bouncing balls using kalman filters and condensation.” [Online]. Available: http:
//www.marcad.com/cs584/Tracking.html
[4] Intel, “Sito ufficiale opensource computer vision librarys.” [Online]. Available: http://www.intel.com/technology/
computing/opencv/index.htm