Processing SURF

` UNIVERSITA DEGLI STUDI DI FIRENZE Facolt` di Ingegneria aCorso di Laurea in INGEGNERIA INFORMATICA

P-SURF: A SURF library for ProcessingElaborato di

Claudio Fantacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Alessandro Martini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Coordinatore: Dr. Walter Nunziati . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Anno Accademico 2008/09

Indice

1 Individuazione dei Punti di Interesse [2] 1.1 1.2 1.3 1.4 Immagine Integrale . . . . . . . . . . . . . . . . . . . . . . . . . . Individuatore Fast-Hessian . . . . . . . . . . . . . . . . . . . . . . Scale-Space . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Localizzazione degli Interest Point . . . . . . . . . . . . . . . . . .

3 3 4 7 9 11 12 14 14 14 15 17 22 24 30 30 35 40 43

2 Descrittore del Punto di Interesse [2] 2.1 Componenti del descrittore . . . . . . . . . . . . . . . . . . . . . .

3 La libreria 3.1 3.2 3.3 3.4 3.5 Obiettivi del nostro lavoro . . . . . . . . . . . . . . . . . . . . . . Linguaggio e ambiente di sviluppo . . . . . . . . . . . . . . . . . . Modello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pattern utilizzati . . . . . . . . . . . . . . . . . . . . . . . . . . . Delega . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4 Punto di interesse 5 Implementazione delle interfacce 5.1 5.2 5.3 5.4 Integral Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . GAUSS Convolution . . . . . . . . . . . . . . . . . . . . . . . . . Detector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HAAR Convolution . . . . . . . . . . . . . . . . . . . . . . . . . . I

INDICE 5.5 5.6

INDICE Descriptor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SURF Factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 52 57 64 64 64 65 65 67 68

6 Risultati 7 Utilizzo della libreria 7.1 7.2 7.3 7.4 Installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mercurial [9] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Passi fondamentali . . . . . . . . . . . . . . . . . . . . . . . . . . Esempi Processing . . . . . . . . . . . . . . . . . . . . . . . . . .

8 Sviluppi futuri 9 Usi possibili

II

IntroduzioneIn questo documento, gli autori presentano la loro implementazione dellalgoritmo SURF in maniera dettagliata. In primo luogo lalgoritmo ` analizzato e da un punto di vista teorico per fornire una panoramica accurata del come e del perch funzioni. Successivamente, sono arontate e motivate la modellazione e le e scelte di sviluppo della libreria. Il compito di cercare delle corrispondenze tra due immagini della stessa scena od oggetto ` parte di molte applicazioni di computer vision. Lobiettivo dellalgoe ritmo SURF ` quello di cercare corrispondenze tra immagini discretizzate e viene e raggiunto in tre passi principali. Primo, gli interest point sono individuati in punti distintivi dellimmagine, quali angoli e giunzioni a T. La pi` importante propriet` dei punti di interesse ` u a e la ripetibilit`, cio` la facilit` con cui tali punti vengono individuati sotto dierenti a e a punti di vista dellimmagine. Successivamente, lintorno di ogni punto di interesse ` rappresentato da un vete tore caratteristico. Questo descrittore deve essere distintivo e, al tempo stesso, robusto al rumore, agli errori di individuazione e alle deformazioni geometriche e fotometriche. Inne, sono confrontati i vettori descrittori tra due dierenti immagini. Il confronto ` spesso basato sulla distanza tra i vettori, per esempio con la distanza e euclidea. Gli autori di SURF hanno sviluppato sia il detector dei punti di interesse

1

INTRODUZIONE che il loro descriptor, ed ` obiettivo di questo documento presentare la nostra e implementazione del loro lavoro.

2

Capitolo 1 Individuazione dei Punti di Interesse [2]1.1 Immagine Integrale

Gran parte dellincremento di performance in SURF pu` essere attribuito alo luso di una rappresentazione intermedia dellimmagine nota come Integral Image. Limmagine integrale ` computata rapidamente dallimmagine di input ed usata e per velocizzare il calcolo di ogni area rettangolare con vertice superiore sinistro nellorigine. Data unimmagine I in input ed un punto di coordinate (x, y), limmagine integrale I (x, y) ` calcolata tramite la somma dei valori dellintensit` dei pixel come a presi tra il punto e lorigine, posta nellangolo superiore sinistro dellimmagine. Formalmente vale la formula:ix jy

I (x, y) =i=0 j=0

I(x, y)

(1.1)

Usando limmagine integrale, il compito di calcolare la somma delle intensit` a di una regione rettangolare qualsiasi si riduce a quattro operazioni. Infatti, se

3

CAPITOLO 1. INDIVIDUAZIONE DEI PUNTI DI INTERESSE [?] consideriamo un rettangolo limitato dai vertici A, B, C e D (Figura 1.1), tale valore si calcola come:

= A + D (C + B)

(1.2)

dove nella formula A, B, C e D sono da intendersi i valori integrali corrispondenti alle coordinate dei vertici. Questo calcolo ` invariante rispetto alla e dimensione dellarea in esame, e SURF fa buon uso di questa propriet` per efa fettuare in modo eciente la convoluzione al variare della dimensioni dei ltri applicati allimmagine.

Figura 1.1: Computazione di unarea usando limmagine integrale.

1.2

Individuatore Fast-Hessian

Il SURF detector ` basato sul determinante della matrice Hessiana. Al ne e di giusticare luso di tale matrice, consideriamo una funzione continua f di due variabili dove il valore della funzione in (x, y) ` dato da f (x, y). La matrice e Hessiana, H, ` la matrice delle derivate parziali della funzione f . e H(f (x, y)) = f (x,y) 2x f (x,y) xy f (x,y) xy f (x,y) 2y

(1.3)

Il determinante di questa matrice, noto anche come discriminante, ` calcolato e come: 4

CAPITOLO 1. INDIVIDUAZIONE DEI PUNTI DI INTERESSE [?]

|H(f (x, y))| =

f (x, y) f (x, y) 2x 2y

f (x, y) xy

2

(1.4)

Il valore del discriminante ` usato per classicare il massimo ed il minimo e della funzione attraverso il test sulle derivate seconde. poich` il determinante ` il e e prodotto degli autovalori della matrice Hessiana, possiamo classicare i punti basandoci sul segno del risultato. Se il determinante ` negativo, allora gli autovalori e hanno segno dierente e perci` il punto non ` un estremo locale; se ` positivo, o e e allora entrambi gli autovalori o sono entrambi positivi o sono entrambi negativi e in entrambi i casi il punto ` classicato come punto estremale. e Tradurre questa teoria alle immagini piuttosto che ad una funzione continua ` e lavoro decisamente complesso. Inizialmente abbiamo sostituito la funzione f (x, y) con lintensit` dei pixel dellimmagine I(x, y). Successivamente avevamo bisogno a di un metodo per calcolare le derivate parziali del secondo ordine dellimmagine. Tali derivate sono calcolate mediante la convoluzione con un appropriato nucleo. Nel caso di SURF, il ltro usato ` quello Gaussiano del secondo ordine nore malizzato poich` permette unanalisi su diverse scale oltre che nello spazio. Tale e questione ` discussa ampiamente nella successiva sezione. e Possiamo costruire i nuclei del ltro in x, y e xy e calcolare cos` i 4 termini della matrice Hessiana. Luso delle Gaussiane permette di variare leetto di smooth durante la fase di convoluzione in modo che il determinante sia calcolato a dierenti scale. Inoltre, poich` la Gaussiana ` una funzione isotropica (i.e. a e e simmetria circolare), la convoluzione col suo nucleo ` invariante alla rotazione. e Calcoliamo perci` la matrice Hessiana come funzione sia dello spazio x = (x, y) o che della scala . (1.5)

Lxx (x, ) Lxy (x, ) H(x, ) = Lxy (x, ) Lyy (x, )

Qui Lxx (x, ) si riferisce alla convoluzione della derivata Gaussiana del secon5

CAPITOLO 1. INDIVIDUAZIONE DEI PUNTI DI INTERESSE [?] do ordineg() 2x

con limmagine nel punto x = (x, y), e analogamente si deniscono

Lyy e Lxy . Queste derivate sono conosciute come LoG (Laplacian of Gaussian). Bay [1] propone unapprossimazione delle LOG tramite delle approssimazioni dei rispettivi nuclei. La Figura 1.2 illustra la somiglianza tra i ltri originali e quelli approssimati e discretizzati. Un notevole incremento di performance si ha con luso congiunto di tali ltri con le immagini integrali. Per quanticare la dierenza, consideriamo il numero di accessi allimmagine per la convoluzione. Per un ltro 9x9 avremmo bisogno di 81 accessi, mentre con luso delle immagini integrali sono necessarie solo 8 operazioni. Allaumentare della dimensione del ltro, il costo di computazione aumenta signicativamente nel calcolo originale, mentre con la tecnica da noi usata rimane invariato.

Figura 1.2: Approssimazioni del Laplacian of Gaussian. Riga superiore: derivate Gaussiane del secondo ordine in direzione x, y e xy discretizzate e approssimate. Nel testo vi facciamo riferimento come Lxx , Lyy , Lxy . Riga inferiore: le approssimazioni utilizzate nellalgoritmo, dove le parti in nero hanno valore positivo e quelle in bianco negativo. Nel testo vi facciamo riferimento come Dxx , Dyy , Dxy . In Figura 1.2 i pesi applicati a ciascuna sezione del ltro sono volutamente semplici. Questo permette di eettuare rapidamente il calcolo delle aree. Bay[1] propone inoltre la seguente formula per unaccurata approssimazione per il determinante dellHessiana usando le Gaussiana approssimate: 6


det(Happrox ) = Dxx Dyy (0.9Dxy )2

(1.6)

La perdita di accuratezza ` ampiamente ripagata da un considerevole aumento e di ecienza e velocit`. a La ricerca per massimi locali nello spazio e attraverso le varie scale conduce allindividuazione dei punti di interesse di unimmagine. Il metodo esatto per la loro estrazione ` illustrato nella seguente sezione. e

1.3

Scale-Space

Al ne di individuare i punti di interesse usando il determinante dellHessiana ` inizialmente necessario introdurre la nozione di scale-space. La scale-space ` e e una funzione che pu` essere usata per trovare punti estremali attraverso tutte le o possibili scale. Nella computer vision, la scale-space ` tipicamente implementata e come una piramide nella quale limmagine di input ` iterativamente convoluta e con il nucleo Gaussiano e ripetutamente ridimensionata. Questo metodo ` usato in SIFT, ma poich` ogni livello dipende dal precedene e te, e le immagini necessitano di essere continuamente ridimensionate, non ` e particolarmente eciente dal punto di vista computazionale. Poich` il costo di elaborazione dei nuclei usati in SURF sono invarianti rispete to alla loro dimensione, la scale-space pu` essere creata applicando nuclei sempre o pi` grandi sullimmagine originale. Questo permette a livelli multipli nella piu ramide della scale-space di essere computati simultaneamente in una eventuale implementazione multithread, ed evitando di ridimensionare limmagine originale si guadagna comunque in prestazioni. La Figura 1.3 nella pagina successiva illustra la dierenza tra la tradizionale scale-space e quella usata in SURF.

7


Figura 1.3: Piramide del ltro. Lapproccio tradizione per costruire lo scalespace (sinistra). La grandezza dellimmagine ` variata ed il ltro Gaussiano e ` ripetutamente applicato sui vari livelli. Lapproccio di SURF (destra) lascia e invariata limmagine originale e varia solamente la dimensione del ltro. La scale-space ` divisa in un numero di ottave, dove ogni ottava fa riferimento e ad una serie di risposte a ltri no al raddoppiamento della loro scala. In SURF, il pi` basso livello della scale-space ` ottenuto come output dei ltri 9x9 mostrati u e in Figura 1.2 a pagina 6. Tali ltri corrispondono ad una Gaussiana con = 1.2. I livelli successivi sono ottenuti incrementando i ltri base e mantenendo le proporzioni (Figura 1.4).

Figura 1.4: Struttura del ltro. Le successive dimensioni dei ltri devono dierire di un minimo di 6 pixel per preservare la struttura del ltro stesso. Poich` la dimensione dei ltri aumenta, cos` fa anche la relativa scala di riferie 8

CAPITOLO 1. INDIVIDUAZIONE DEI PUNTI DI INTERESSE [?] mento, e poich` si mantengono le proporzioni possiamo calcolarla con la seguente e formula: BaseF ilterScale BaseF ilterSize 1.2 9

approx = CurrentF ilterSize

(1.7)

= CurrentF ilterSize

Figura 1.5: Set dei ltri al variare della scala e dellottava.

1.4

Localizzazione degli Interest Point

Il compito di localizzare la scala dei punti di interesse in unimmagine pu` o essere divisa in tre passi. Inizialmente, le risposte vengono ltrate con un valore di soglia in modo che valori al di sotto di tale valore vengano scartati. Aumentando la soglia si diminuiscono i punti individuati. Successivamente, viene attuata una non-maximal suppression per trovare un set di punti candidati. Per fare ci`, ciascun pixel nella scale-space ` confrontato o e con i suoi 26 punti vicini, compresi gli 8 punti della nativa scala e i 9 di ogni scala superiore ed inferiore. La Figura 1.6 nella pagina seguente illustra tale concetto. A questo punto abbiamo un set di punti di interesse ltrati e che sono inoltre minimi o massimi nello scale-space. 9

CAPITOLO 1. INDIVIDUAZIONE DEI PUNTI DI INTERESSE [?] Il passo nale consiste nellinterpolare i dati vicini al ne di localizzare con accuratezza i punti. Questultimo passo ` stato trascurato nella nostra implee mentazione.

Figura 1.6: Non-Maximal Suppression. Il pixel evidenziato con X ` selezionato e come un massimo se ha un valore maggiore dei pixel che lo circondano alla sua scala, quella superiore e quella inferiore.

10

Capitolo 2 Descrittore del Punto di Interesse [2]I descrittori SURF descrivono come lintensit` dei pixel ` distribuita nellina e torno dei punti di interesse individuati dalla Fast-Hessian. A tale risultato si perviene tramite lutilizzo di ltri Haar, che possono essere usati per trovare i gradienti nelle direzioni x e y.

Figura 2.1: Haar Wavelets. Il ltro a sinistra computa la risposta nella direzione x, mentre il ltro a destra computa nella direzione y. I pesi sono 1 per le regioni nere e -1 per le regioni bianche. Quando questi ltri sono usati con le immagini integrali, sono necessarie solo 6 operazioni per ottenere il risultato. Lestrazione dei descrittori pu` essere divisa in 2 fasi. Prima per ogni punto di o interesse viene individuata una orientazione e successivamente si costruisce una nestra centrata sul punto, la cui dimensione dipende dalla scala alla quale il pun11

CAPITOLO 2. DESCRITTORE DEL PUNTO DI INTERESSE [?] to di interesse stesso ` stato trovato. Da tale area, e con luso congiunto dei ltri e Haar ed attraverso limmagine integrale, si estrae un vettore di 64 componenti. Per semplicare il progetto, la parte riguardante lindividuazione dellorientazione del punto ` stata tralasciata. Tuttavia, il modello del progetto ` predisposto e e per ampliamenti futuri.

2.1

Componenti del descrittore

Il primo passo nellestrazione dei descrittori SURF consiste nel costruire una nestra quadrata centrata nel punto di interesse. Questa nestra contiene i pixel che produrranno il descrittore e la sua dimensione ` 20, dove ancora si e riferisce alla scala alla quale il punto di interesse ` stato individuato. Nel nostro e lavoro, la nestra ` sempre allineata parallelamente ai lati dellimmagine, mentre e unimplementazione fedele alloriginale prevede di orientarla in maniera concorde allorientazione del punto. La nestra del descrittore ` divisa in sottoregioni regolari 4x4. Allinterno di e ciascuna sottoregione i ltri Haar, di dimensione 2, sono applicati su 25 punti regolarmente distribuiti. Se ci riferiamo alla risposta lungo x e y con dx e dy, allora per ciascuna sottoregione (i.e. per i 25 punti campione) abbiamo:

vsubregion =

dx,

dy,

|dx|,

|dy|

(2.1)

12

CAPITOLO 2. DESCRITTORE DEL PUNTO DI INTERESSE [?]

Figura 2.2: Componenti del Descriptor. Il bordo verde del quadrato ` uno delle e 16 sottoregioni ed i cerchi blu rappresentano i campioni sui quali computiamo la risposta alle Haar Wavelets.

13

Capitolo 3 La libreria3.1 Obiettivi del nostro lavoro

Lobiettivo che ci eravamo pressati era quello di fornire unimplementazione essibile e completa a livello concettuale. Il modello che forniamo si presta ad essere approfondito rispetto a come i vari componenti vengono programmati, ma risulta gi` completo da un punto di vista architetturale. a In futuro, chiunque voglia mettere mano alla libreria dovr` solamente adottare le a nostre interfacce e scriverne nuove implementazioni.

3.2

Linguaggio e ambiente di sviluppo

Il linguaggio di programmazione utilizzato per limplementazione ` il Procese sing [5]. Processing ` un linguaggio di programmazione Open Source orientato e agli oggetti che ` stato creato per agevolare lo sviluppo di applicazioni che fane no uso di immagini, animazioni o, pi` in generale, di materiale multimediale. u Questo linguaggio ` basato su Java, ma poich` alcuni oggetti sono stato semplie e cati ` possibile usarlo anche se non si ha alcuna base di Java, daltro canto, per e coloro che hanno familiarit` con questultimo linguaggio, risulter` molto facile a a

14

CAPITOLO 3. LA LIBRERIA utilizzarlo anche in modo avanzato e lo si pu` sfruttare anche in IDE (Integrated o Development Environment) di programmazioni di terze parti professionali quali Eclipse [6]. Un programma in Processing ` chiamato Sketch. Lidea che sta alla base ` quella e e di produrre programmi in stile Java, ma farli sembrare pi` simili possibile a degli u script cos` da velocizzare la scrittura del codice. Gli Sketch sono salvati allinterno di Sketchbook, una cartella che ` usata di default per salvare tutti i progetti. e Lapproccio utilizzato per limplementazione della libreria in Processing ` e stato suddiviso in cinque punti: Astrazione delle classi coinvolte nel progetto e creazione di un diagramma UML; implementazione in Processing delle classi; riorganizzazione delle classi ed utilizzo di Patterns specici per migliorare e rendere p`u scalabile limplementazione; ` esportazione del codice in Eclipse e creazione della libreria; reverse engineering per ranare il diagramma UML iniziale con eUML2 [8].

3.3

Modello

Di seguito viene riportato il diagramma UML per intero del progetto. Successivamente verranno analizzate le singole parti in dettaglio.

15

CAPITOLO 3. LA LIBRERIA

Figura 3.1: Modello UML. 16

CAPITOLO 3. LA LIBRERIA

3.4

Pattern utilizzati

Progettare software ad oggetti ` dicile; riuscire a renderlo usabile ` ancora e e pi` dicile. Occorre trovare gli oggetti giusti, fattorizzarli in classi con la giusta u granularit`, denire interfacce e gerarchie di ereditariet` e stabilire tra queste le a a relazioni fondamentali. La progettazione dovrebbe essere specica per il problema che si sta arontando, ma anche sucientemente generica per problemi e requisiti futuri. Ogni pattern descrive un problema che si ripete pi` e pi` volte nel nostro u u ambiente, descrive poi il nucleo della soluzione del problema, in modo tale che si possa usare la soluzione un milione di volte senza mai applicarla nella stessa maniera. Da un punto di vista implementativo il dubbio che sorge spontaneo ` la e scelta di estendibilit` del codice attraverso lereditariet` di interfaccia o di classe. a a Innanzitutto dierenziamo la classe di un oggetto ed il suo tipo. La prima denisce il modo in cui questo viene implementato, lo stato delloggetto e le modalit` a di implementazione dei suoi metodi. Il tipo, invece, denisce solo linterfaccia delloggetto, ossia linsieme delle richieste a cui questo pu` rispondere. Un ogo getto pu` avere pi` tipi, ed oggetti di classi diverse possono avere lo stesso tipo. o u Esiste comunque una forte dipendenza fra la classe di un oggetto ed il suo tipo. Infatti, poich` una classe denisce le operazioni che un oggetto pu` svolgere, e o implicitamente denisce anche il tipo delloggetto. Quando si aerma che un oggetto ` listanza di una classe, si d` per scontato che loggetto ora eettivamente e a linterfaccia denita dalla classe stessa. Lereditariet` di classe ` solamente un meccanismo per estendere le funzionaa e lit` di unapplicazione riusando le funzionalit` delle classi padre. In questo modo a a ` possibile denire rapidamente un nuovo oggetto basandosi su uno vecchio. E e possibile ottenere una nuova implementazione con poco, ereditando la maggior parte di quello di cui si ha bisogno da classi esistenti. Il riuso dellimplementazione ` solo met` del problema. La possibilt` oerta e a a 17

CAPITOLO 3. LA LIBRERIA da uninterfaccia di denire una famiglia di oggetti con interfacce identiche ` a sua e volta importante. E importante perch` il polimorsmo dipende solo da questa e caratteristica. Quando lereditariet` viene usata oculatamente (altri direbbero propriamena te) tutte le classi che ereditano da una classe astratta condivideranno la sua interfaccia. Questo implica che una sottoclasse pu` aggiungere o reimplementare o i metodi di una classe padre, ma non pu` nasconderli. Tutte le sottoclassi possoo no quindi gestire le richieste che la classe padre pu` gestire, rendendole tutte dei o sottotipi delle classe astratte. Ci sono due vantaggi nel gestire gli oggetti esclusivamente facendo riferimento alle interfacce: I client restano inconsapevoli dei tipi specici degli oggetti che usano, sempre che questi oggetti siano confomri allinterfaccia che i client si aspettano; i client restano inconsapevoli della classe che eettivamente implementa questi oggetti. I client conoscono solo linterfaccia. Queste propriet` riducono molto le dipendenze implementative tra sottosistemi, a da cui il seguente principio per ottenere progetti ad oggetti riusabili: Si deve sempre programmare riferendosi ad uninterfaccia, non ad una implementazione. Le classi che possono essere istanziate sono le classi concrete e non le interfacce. In particolare, i pattern usati nello sviluppo di SURF sono detti creazionali e permettono di istanziare classi concrete indirettamente, cio` senza chiamare lo spee cico costruttore, ma rifacendosi a metodi che restituiscono loggetto istanziato. Ancora una volta si ribadisce il fatto che i pattern di creazione garantiscano che il sistema sia scritto facendo riferimento alle interfacce e non alle implementazioni.

18

CAPITOLO 3. LA LIBRERIA Abstract Factory Astact Factory ` un pattern creazionale basato su oggetti che fornisce unintere faccia per la creazione di famiglie di oggetti correlati o dipendenti senza specicare quali siano le loro classi concrete.

Figura 3.2: Modello UML del Pattern Abstract Factory. Il pattern Abstract Factory pu` essere utilizzato quando: o un sistema deve essere indipendente dalle modalit` di creazione, composia zione, rappresentazione dei suoi prodotti; un sistema deve poter essere congurato scegliendo una tra pi` famiglie di u prodotti; esistono famiglie di oggetti correlati, progettati per essere utilizzati insieme, e occorre garantire che questo vincolo sia rispettato; si vuole fornire una libreria di classi, rivelando soltanto le loro interfacce e non le implementazioni. Luso del pattern Abstract Factory ha i seguenti vantaggi e svantaggi: 19

CAPITOLO 3. LA LIBRERIA 1. Isola le classi concrete. Il pattern Abstract Factory aiuta a controllare le classi di oggetti creati da unapplicazione. Poich` una factory incapsula la e responsabilit` e il processo di creazione di oggetti prodotto, rende i clienti ina dipendenti dalle classi eettivamente utilizzate per limplementazione degli oggetti. I client manipolano le istanze soltanto attraverso le loro interfacce astratte. I nomi delle classi prodotto sono connati nellimplementazione della factory concreta e non appaiono nel codice client. 2. Consente di cambiare in modo semplice la famiglia di prodotti utilizzata. La classe che rappresenta una factory concreta appare in un solo punto allinterno dellapplicazione, quando deve essere istanziata. Il cambiamento della factory concreata utilizzata da unapplicazione ` quindi semplicato e ed ` possibile ottenere una congurazione di oggetti diversi semplicemente e cambiando la factory concreta da utilizzare. Poich` una factory concreata e gestisce la creazione di unintera famiglia di prodotti, la scelta di una factory concreata seleziona unintera famiglia di prodotti. 3. Promuove la coerenza nellutilizzo di prodotti. Gli oggetti prodotti di una famiglia sono stati progettati per operare insieme, ` importante che unape plicazione utilizzi oggetti di una sola famiglia per volta. Linterfaccia AbstractFactory consente di rispettare questo vincolo. 4. Laggiunta del supporto per nuove tipologie di prodotti ` dicile. Estendee re Factory astratte per sopportare nuove tipologie di prodotti non ` seme plice, poich` linterfaccia AbstractFactory determina linsieme di prodotti e che possono essere dellinterfaccia e la conseguente modica della classe AbstractFactory e delle sue sottoclassi.

20

CAPITOLO 3. LA LIBRERIA Singleton Singleton ` un pattern creazionale basato su oggetti che serve ad assicurare e che una classe abbia una sola istanza e fornire un punto daccesso globale a tale istanza. E importante poter assicurare che per alcune classi esista una sola istanza. Per esempio, in un sistema dovrebbe essere presente un solo le system e un solo window manager. La soluzione migliore consiste nel fare in modo che la classe stessa abbia la responsabilit` di creare le proprie istanze. La a classe pu` assicurare che nessunaltra istanza possa essere creata (intercettando o le richieste di creazione di nuovi oggetti) e pu` fornire un modo semplice per o accedere allistanza. Questo ` il pattern Singleton. e

Figura 3.3: Modello UML del Pattern Singleton. Il pattern Singleton pu` essere usato: o quando deve esistere esattamente unistanza di una classe e tale istanza deve essere resa accessibile ai client attraverso un punto di accesso noto a tutti gli utilizzatori; quando lunica istanza deve poter essere estesa attraverso la denizione di sottoclassi e i client devono essere in grado di utilizzare le istanze estende senza dover modicare il proprio codice. Il patter Singleton ore molteplici beneci: 21

CAPITOLO 3. LA LIBRERIA 1. Accesso controllato a ununica istanza. Poich` la classe Singleton incapsula e la sua unica istanza, pu` mantenere un controllo stretto sulle modalit` e i o a tempi con i quali i client possono accedere allistanza. 2. Riduzione dello spazio dei nomi. Il pattern Singleton rappresenta un miglioramento rispetto alluso di variabili globali. Evita di inquinare ilo spazio dei nomi con variabili globali utilizzate per memorizzare i riferimenti alle singole istanze. 3. Permette il ranamento di operazioni e rappresentazione. E possibile denire delle sottoclassi della classe Singleton ed ` semplice congurare unape plicazione in esecuzione in modo da utilizzare unistanza di questa classe estesa. 4. Permette di gestire un numero variabile distanze. Il pattern consente di gestire pi` di una singola istanza della classe Singleton e lo stesso approcu cio pu` essere usato per controllare il numero distanze utilizzare dallapo plicazione. Per ottenere questo risultato ` necessario modicare soltanto e loperazione responsabile della gestione dellaccesso allistanza di Singleton.

3.5

Delega

Nella progettazione di un software la delega ` un modo per far s` che la come posizione diventi, per quanto riguarda il riuso, uno strumento potente quanto lereditariet`. Nella delega, si usano due oggetti per gestire una richiesta: loggetto a che riceve la richiesta delega la risposta al proprio delegato. Questo ` analogo e alle sotto-classi che passa la gestione di una richiesta alle loro classi padre. Ma nellereditariet`, unoperazione ereditata pu` sempre far riferimento alloggetto a o ricevente attraverso attributi specici come il this del Java o del C++. Per ottenere lo stesso comportamento con la delega, il ricevente deve passare s` stesso e

22

CAPITOLO 3. LA LIBRERIA a delegato per fare in modo che le operazioni del delegato facciano riferimento al ricevente. Il vantaggio principale della delega consiste nel fatto che permette facilmente di comporre comportamenti in fase di esecuzione e di cambiare in il modo con cui questi comportamenti sono composti. Lo svantaggio, tuttavia, che condivide con altre tecniche atte a rendere il software pi` essibile attraverso la u composizione di oggetti ` che il software dinamico e fortemente parametrizzato ` e e pi` dicile da capire rispetto al software pi` statico. Il software pi` dinamico ` u u u e anche pi` ineciente in esecuzione, ma le inecienze umane sono pi` importanti u u a lungo termine. La delega ` una buona scelta progettuale solo quando semplica e il progetto piuttosto che complicarlo. Non ` facile dare indicazioni precise su e quando usare la delega, poich` la sua ecacia dipende dal contesto e dallespee rienza che si ha usando la delega tuttavia funziona al meglio quando ` stata usata e seguendo modelli specici, ossia nei pattern.

23

Capitolo 4 Punto di interesseLa nostra libreria denisce un nuovo tipo di dato: Interest P oint. Viene ora presentata la sua struttura generale, che ` alla base del funzionamento di tutte e le classi che verranno successivamente descritte.

Scopo Lo scopo di tale struttura dati ` quello di riunire in ununica classe tutte e le informazioni riguardanti un singolo punto di interesse: posizione, orientazione, scala e relativo descrittore.

Struttura

Figura 4.1: Struttura della classe Interest Point.

Metodi 24

CAPITOLO 4. PUNTO DI INTERESSE 1. Interest P oint

Parametri: x: coordinata x del punto di interesse; y: coordinata y del punto di interesse; scale: scala alla quale il punto ` stato individuato; e orientation x: valore di orientazione lungo x; orientation y: valore di orientazione lungo y; DescriptorOfTheInterestPoint: vettore descrittivo del punto a 64 componenti; parent: PApplet per loutput video. Codice:/ C o s t r u t t o r e u t i l i z z a t o n e l l a n o s t r a l i b r e r i a , n e l l a q u a l e l o r i e n t a z i o n e non ` s t a t a e c a l c o l a t a ma p o s t a d i d e f a u l t a 0 /

public Interest Point ( float x , float y , float PApplet p a r e n t ) {

scale ,

this .x = x; this .y = y; this . scale = scale ;

this . orientation x = 0; this . orientation y = 0; this . orientation radius = 0; t h i s . parent = parent ;

25

CAPITOLO 4. PUNTO DI INTERESSE}

public Interest Point ( float x , float y , float

scale ,

int orientation x , int orientation y , f l o a t [ ] descriptorOfTheInterestPoint , PApplet p a r e n t ) {


this . orientation x = orientation x ; this . orientation y = orientation y ; this . orientation radius = Math . atan2 ( o r i e n t a t i o n y y , o r i e n t a t i o n x x ) ; this . descriptorOfTheInterestPoint = descriptorOfTheInterestPoint ; t h i s . parent = parent ;

}

public Interest Point ( float x , float y , float

scale ,

int orientation x , int orientation y , PApplet p a r e n t ) {


this . orientation x = orientation x ; this . orientation y = orientation y ; this . orientation radius =

26

CAPITOLO 4. PUNTO DI INTERESSEMath . atan2 ( o r i e n t a t i o n y y , o r i e n t a t i o n x x ) ; t h i s . parent = parent ;

}

2. getInterestPointInformationAsAString

Parametri: nessuno. Valore di ritorno: String: stringa nella quale sono presenti le coordinate del punto e le 64 componenti del descrittore associato separati da spazio. Codice:public String getInterestPointInformationAsAString () {

S t r i n g i n f o r m a t i o n = new S t r i n g ( ) ; i n f o r m a t i o n += x + + y + ; f o r ( i n t i =0; i 0) {

integralValues [ i ] [ j ] = i n t e g r a l V a l u e s [ i 1 ] [ j ]+ sumOfTheCurrentRow ;

} else {

integralValues [ i ] [ j ] = sumOfTheCurrentRow ;

} } } }

Costruttore di M y Integral Image. Il costruttore riceve limmagine ed eettua la conversione nella sua versione integrale. E allocata una matrice, integralValues, di interi della stessa dimensione dellimmagine data. Limmagine integrale ` completamente calcolata come segue: e Alla prima riga, la somma diretta delle intensit` (brightness) dei pixel a in ogni punto rappresenta direttamente il corretto valore integrale; Per ogni riga successiva, il corretto valore ` dato dalla somma della e 32

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE riga corrente e della cella della matrice alle stesse coordinate del pixel immediatamente al di sopra del punto in esame. 2. getIntegralValue

Parametri: x: coordinata x del punto che costituisce uno dei due vertici caratterizzanti del rettangolo. Laltro ` lorigine (0,0); e y: coordinata y del punto che costituisce uno dei due vertici caratterizzanti del rettangolo. Laltro ` lorigine (0,0). e Valore di ritorno: oat: valore integrale dellarea indicata. Codice:public float getIntegralValue ( int x , int y) {

i f ( ( y < 0 | | y >= img . h e i g h t ) | | ( x < 0 | | x >= img . width ) ) {

return 0 ;

} else {

return i n t e g r a l V a l u e s [ y ] [ x ] ;

}

}

33

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE Questo metodo ritorna il valore integrale relativo al punto di coordinate (x, y), cio` lintensit` del rettangolo i cui vertici caratterizzanti sono lorigine e a (0,0) dellimmagine e (x, y). Si fa notare come allinterno del metodo limmagine ` vista come una matrice: le ordinate corrispondono alle righe e le e ascisse alle colonne. 3. getIntegralSquare

Parametri: xA: coordinata x del vertice A; yA: coordinata y del vertice A; xD: coordinata x del vertice D; yD: coordinata y del vertice D; Valore di ritorno: oat: valore integrale dellarea indicata. Codice:p u b l i c f l o a t g e t I n t e g r a l S q u a r e ( i n t xA , i n t yA , i n t xD , i n t yD) {

f l o a t A = g e t I n t e g r a l V a l u e (xA , yA ) ; f l o a t D = g e t I n t e g r a l V a l u e (xD , yD ) ; f l o a t B = g e t I n t e g r a l V a l u e (xD , yA ) ; f l o a t C = g e t I n t e g r a l V a l u e (xA , yD ) ; return A + D (C + B ) ;

}

34

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE Il metodo ritorna il valore integrale del rettangolo i cui vertici caratterizzanti sono (xA, yA) e (xD, yD). Si ` adottata la convenzione mostrata in 1.1 a e pagina 3, con particolare riferimento alla Figura 1.1 a pagina 4.

5.2

GAUSS Convolution

Scopo E uninterfaccia per il calcolo della convoluzione tra limmagine e i vari ltri Gaussiani.

Specializzazione La specializzazione dellinterfaccia GAU SS Convolution ` e M y GAU SS Convolution. Questa implementazione prevede il calcolo della convoluzione tra limmagine, in forma integrale, e i vari ltri Gaussiani (Figura 1.2 a pagina 6) nelle dierenti direzioni come esposto in 1.2 a pagina 4.

Struttura

Figura 5.2:

Interfaccia GAUSS Convolution e la nostra implementazione

My GAUSS Convolution.

35

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE Implementazione 1. M y GAU SS Convolution

Parametri: integralImage: immagine integrale sulla quale eseguire la convoluzione. Codice:p u b l i c My GAUSS Convolution ( I n t e g r a l I m a g e i n t e g r a l I m a g e ) {

this . integralImage = integralImage ;

}

Il costruttore di M y GAU SS Convolution ha come unico scopo quello di avere un riferimento allimmagine integrale da utilizzare successivamente per il calcolo della convoluzione. 2. makeConvolutionDxx

Parametri: x: coordinata x del punto su cui viene eseguita la convoluzione; y: coordinata y del punto su cui viene eseguita la convoluzione; ltersize: dimensione del lato del ltro. Valore di ritorno: oat: valore della convoluzione.

36

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE

Codice:p u b l i c f l o a t makeConvolutionDxx ( i n t x , i n t y , int f i l t e r s i z e ) {

i n t x1 , x2 , x3 , x4 , y1 , y2 ; int center , lobe size1 , l o b e s i z e 2 ;

center = ( f i l t e r s i z e 1) / 2 ; lobe size1 = f i l t e r s i z e / 3; l o b e s i z e 2 = 5 + 4 ( f i l t e r s i z e 9) / 6 ;

x1 = x c e n t e r ; x4 = x + c e n t e r ; x2 = x c e n t e r + l o b e s i z e 1 ; x3 = x + c e n t e r l o b e s i z e 1 ; y1 = y ( l o b e s i z e 2 1 ) / 2 ; y2 = y + ( l o b e s i z e 2 1 ) / 2 ;

return ( i n t e g r a l I m a g e . g e t I n t e g r a l S q u a r e ( x2 , y1 , x3 , y2 ) 3 i n t e g r a l I m a g e . g e t I n t e g r a l S q u a r e ( x1 , y1 , x4 , y2 ) ) ;

}

Il metodo ritorna il valore della convoluzione nel punto (x, y) con un ltro di lato f iltersize. Vengono pertanto inizialmente individuate le coordinate dei vari punti necessari al successivo calcolo. Allo scopo, nelle variabili lobe size1 e lobe size2, vengono inserite, rispettivamente, le lunghezze di 37

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE AB e di DH. Per capire il funzionamento del metodo, si faccia riferimento al seguente schema:

O----------------------> |--------------------| 0 |

j

A------B------C------D | -1 | +2 | -1 |

E------F------G------H | 0 |

|--------------------| v

i

Il ltro Dxx si muove sullimmagine. Per computare il valore della convoluzione basta semplicemente fare:

2 Area(BCF G) Area(ABEF ) Area(CDGH)

usando limmagine integrale. Sinteticamente:

E + D (A + H) + 3(B + G (C + F ))

Sottraiamo cio` il rettangolo AEDH e sommiamo 3 volte il rettangolo cene trale. Sono richiesti pertanto solo 8 accessi allimmagine integrale ad ogni passo invece di un numero pari allarea del ltro come nella denizione stan38

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE dard. Allo stesso modo vengono calcolate le convoluzioni con gli altri due ltri Dxy e Dyy con il semplice cambio di coordinate. Gli schemi di riferimento sono riportati di seguito.

O------------------------> |----------------------| | | | | | | | I------L | +1 | M------N | -1 | A------B | -1 | C------D | +1 | | | | | | | |

E------F

G------H

O------P

Q------R

|----------------------| | v

Il valore della convoluzione ` dato da Area(CDGH) Area(ABEF ) + Area(ILOP ) e Area(M N QR) usando limmagine integrale. Sinteticamente, B + E + C + H + I + P + N + Q (A + F + D + G + L + O + M + R). Sono richiesti pertanto solo 12 accessi allimmagine integrale ad ogni passo invece di un numero pari allarea del ltro come nella denizione standard.

39

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE O----------------------> |------A------B------| | | | | | | -1 | | | | | |

C------D | +2 |

E------F | -1 |

|------G------H------| | v

Il valore della convoluzione ` dato da 2 Area(CDEF ) Area(ABCD) Area(EF GH) e usando limmagine integrale. Sinteticamente, B + G (A + H) + 3(C + F (D + E)): sottraiamo il rettangolo ABGH e sommiamo tre volte il rettangolo centrale. Sono richiesti pertanto solo 8 accessi allimmagine integrale ad ogni passo invece di un numero pari allarea del ltro come nella denizione standard.

5.3

Detector

Scopo E uninterfaccia adibita allindividuazione dei punti di interesse allinterno di unimmagine.

Specializzazione La specializzazione dellinterfaccia Detector ` Fast Hessian, e che prevede lutilizzo del ltro Hessiano come presentato in 1.2-1.4. Tale compito ` svolto mediante lutilizzo di Integral Image. e

40

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE Struttura

Figura 5.3: Interfaccia Detector e la nostra implementazione Fast Hessian.

Implementazione 1. M y Integral Image

Parametri: integralImage: versione integrale dellimmagine sulla quale ricercare i punti di interesse; imgWidth: larghezza dellimmagine; imgHeight: altezza dellimmagine; balanceValue: valore di peso per il calcolo del determinante della matrice Hessiana; threshold: valore di soglia per ltrare i punti; octaves: numero di ottave; parent: PApplet per loutput video.

41


Codice:public Fast Hessian ( Integral Image integralImage , i n t imgWidth , i n t imgHeight , f l o a t b al an c eV al u e , f l o a t threshold , i nt octaves , PApplet p a r e n t ) {

...

t h i s . gaussConvolution = new My GAUSS Convolution ( i n t e g r a l I m a g e ) ; interestPoints = new A r r a y L i s t ( ) ; hessianDeterminantsByOctaves = new A r r a y L i s t ( o c t a v e s ) ;

...

}

Il costruttore di F ast Hessian, oltre ad inizializzare i suoi attributi coi parametri attuali, prevede il calcolo della convoluzione tramite ltri Gaussiani su tutta limmagine integrale. Questo ` realizzato tramite luso della classe e M y Gauss Convolution che implementa linterfaccia Gauss Convolution. Per il salvataggio dei punti di interesse ` stato usato e ArrayList. Inne, per memorizzare i valori della matrice Hessiana alle varie ottave, alle varie scale, ` stato usato un ArrayList di ArrayList di matrici e di oat.

42

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE 2. generateInterestP oints

Parametri: nessuno Valore di ritorno: ArrayList : ArrayList contenente i punti di interesse individuati, privi di descrittore. Codice:p u b l i c A r r a y L i s t g e n e r a t e I n t e r e s t P o i n t s ( ) {

buildDet ( ) ; threshold ( ) ; nonMaximalSuppression ( ) ; return i n t e r e s t P o i n t s ;

}

Questo metodo calcola tutte le matrici dei determinanti (buildDet()) ad ogni ottava, ad ogni scala; successivamente ltra il risultato (thresold()) ed inne applica una soppressione non massimale (nonM aximalSuppression()) per determinare i punti di interesse, che vengono restituiti. Tutto questo ` e in accordo con quanto espresso in 1.3 e 1.4.

5.4

HAAR Convolution

Scopo E uninterfaccia per il calcolo della convoluzione tra limmagine e i vari ltri Haar.

43

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE Specializzazione La specializzazione dellinterfaccia HAAR Convolution ` e M y HAAR Convolution. Questa implementazione prevede il calcolo della convoluzione tra limmagine, in forma integrale, e i vari ltri Haar (Figura 2.1 a pagina 11) nelle dierenti direzioni come esposto in 2 a pagina 11.

Struttura

Figura 5.4:

Interfaccia HAAR Convolution e la nostra implementazione

My HAAR Convolution.

Implementazione 1. M y HAAR Convolution

Parametri: integralImage: immagine integrale sulla quale eettuare la convoluzione.

44


Codice:p u b l i c My HAAR Convolution ( I n t e g r a l I m a g e i n t e g r a l I m a g e ) {

this . integralImage = integralImage ;

}

Il costruttore prevede il solo riferimento allimmagine integrale passata come parametro attuale. 2. makeConvolutionDx

Parametri: x: y: scale: Valore di ritorno: oat: valore della convoluzione lungo la direzione x. Codice:p u b l i c f l o a t makeConvolutionDx ( i n t x , i n t y , f l o a t i n t x1 , x2 , x3 , y1 , y3 ; scale ) {

x1 = ( i n t ) ( x x2 = ( i n t ) x ; x3 = ( i n t ) ( x + y1 = ( i n t ) ( y

scale );

scale ); scale );

45


y3 = ( i n t ) ( y +

scale );

return ( i n t e g r a l I m a g e . g e t I n t e g r a l S q u a r e ( x1 , y1 , x2 , y3 ) i n t e g r a l I m a g e . g e t I n t e g r a l S q u a r e ( x2 , y1 , x3 , y3 ) ) ;

}

Questo metodo prevede il calcolo della convoluzione con il ltro Haar destro (lungo lasse delle ascisse) come dierenza dei valori integrali dei rettangoli i cui vertici caratterizzanti sono (x1, y1), (x2, y3) e (x2, y1), (x3, y3) rappresentati nella prima delle gura sottostante: O-----------------------------------------------> | | | | | | | | | v y3 x1 y1 x2 x3 y1 | | x1 ----------W -1 | | x3 x

----------| | | | | 1 B | | | -1 | | W | | | | |

y2 |-----------| | | y3 B 1 | |

-----------

-----------

y Analogamente viene eseguita la convoluzione sul ltro sinistro (relativo cio` e allasse delle ordinate) come dierenza dei valori integrali dei rettangoli i cui vertici caratterizzanti sono (x1, y1), (x3, y2) e (x1, y2), (x3, y3) referenziabili nella seconda gura del schema precedente. 46


5.5

Descriptor

Scopo E uninterfaccia che ha il compito di generare i descrittori dei punti di interesse.

Specializzazione La specializzazione dellinterfaccia Descriptor ` e SU RF Descriptor. Questa implementazione usa limmagine integrale per computare le risposte dei ltri Haar ed estrarre un descrittore di 64 componenti basati sulla somma delle risposte stesse.

Struttura

Figura 5.5: Interfaccia Descriptor e la nostra implementazione SURF Descriptor.

Implementazione 1. SU RF Descriptor

Parametri: interest points:

47

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE integralImage: immagine integrale sulla quale calcolare i descrittori dei punti di interesse. Codice:p u b l i c SURF Descriptor ( A r r a y L i s t i n t e r e s t p o i n t s , Integral Image integralImage ) { ... t h i s . haarConvolution = new My HAAR Convolution ( i n t e g r a l I m a g e ) ; }

Il costruttore prevede, oltre al riferimento ai parametri attuali, ad istanziare un oggetto HAAR Convolution, necessario per le successive somme per il calcolo dei descrittori. 2. generateAllDescriptors

Parametri: nessuno Valore di ritorno: void Codice:public void g e n e r a t e A l l D e s c r i p t o r s ( ) {

f l o a t [ ] V a l u e D e s c r i p t o r = new f l o a t [ 6 4 ] ; Interest Point currentIP ; i n t x1 , y1 , x2 , y4 ; i n t xf , y f ;

48

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCEf o r ( i n t i = 0 ; i < i n t e r e s t p o i n t s . s i z e ( ) ; i ++) { ... c u r r e n t I P = ( I n t e r e s t P o i n t ) i n t e r e s t p o i n t s . get ( i ) ;

x1 = ( i n t ) ( c u r r e n t I P . getX ( ) c u r r e n t I P . g e t S c a l e ( ) 1 0 ) ; y1 = ( i n t ) ( c u r r e n t I P . getY ( ) c u r r e n t I P . g e t S c a l e ( ) 1 0 ) ; x2 = ( i n t ) ( c u r r e n t I P . getX ( ) + c u r r e n t I P . g e t S c a l e ( ) 1 0 ) ; y4 = ( i n t ) ( c u r r e n t I P . getY ( ) + c u r r e n t I P . g e t S c a l e ( ) 1 0 ) ;

f o r ( i n t j = 0 ; j < 2 0 ; j ++) {

x f = ( i n t ) x1 + ( j + 1 ) ( x2 x1 ) / 2 0 ;

f o r ( i n t k = 0 ; k < 2 0 ; k++) {

y f = ( i n t ) y1 + ( k + 1 ) ( y4 y1 ) / 2 0 ;

double gaussValue = g a u s s i a n ( x f c u r r e n t I P . getX ( ) , yf c u r r e n t I P . getY ( ) , 3 . 3 f c u r r e n t I P . g e t S c a l e ( ) ) ;

f l o a t DxToWeight = h a a r C o n v o l u t i o n . makeConvolutionDx ( xf , yf , currentIP . getScale ( ) ) ; f l o a t DyToWeight = h a a r C o n v o l u t i o n . makeConvolutionDy ( xf , yf , currentIP . getScale ( ) ) ;

V a l u e D e s c r i p t o r [ ( i n t ) ( 4 Math . f l o o r ( j / 5 ) + 16 Math . f l o o r ( k / 5 ) ) ] +=

49

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCEg a u s s V a l u e DxToWeight ; V a l u e D e s c r i p t o r [ ( i n t ) ( 4 Math . f l o o r ( j / 5 ) + 16 Math . f l o o r ( k / 5 ) + 1 ) ] += g a u s s V a l u e DyToWeight ; V a l u e D e s c r i p t o r [ ( i n t ) ( 4 Math . f l o o r ( j / 5 ) + 16 Math . f l o o r ( k / 5 ) + 2 ) ] += Math . abs ( g a u s s V a l u e DxToWeight ) ; V a l u e D e s c r i p t o r [ ( i n t ) ( 4 Math . f l o o r ( j / 5 ) + 16 Math . f l o o r ( k / 5 ) + 3 ) ] += Math . abs ( g a u s s V a l u e DyToWeight ) ; }

}

normalizeDescriptor ( ValueDescriptor ) ; currentIP . setDescriptorOfTheInterestPoint ( ValueDescriptor ) ;

}

}

Innanzi tutto si faccia riferimento alla gura seguente per meglio comprendere il funzionamento di questo metodo:

50

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE O--------------------------------> | | | | | | | | | | | v x1,y1 --- --- --- --- x2,y2 | | | | | x

|---|---|---|---| | | | | |

|---|---|---|---| | | | | |

|---|---|---|---| | | | | |

x4,y4 --- --- --- --- x3,y3

y

Per ogni punto di interesse prelevato dallarraylist vengono calcolati i punti x1, y1,x2, y4 i quali deniscono i limiti della nestra in accordo a quanto riportato in 2.1 a pagina 12, ove il punto di interesse ` il centro della stessa. e Viene calcolato il valore della gaussiana tridimensionale tramite il metodo privato gaussian() che riceve come parametri la distanza del campione attualmente in esame dal centro della nestra e la varianza calcolata come 3.3 volte il fattore di scala del punto di interesse; il valore ricavato viene usato per pesare opportunamente le risposte ai ltri prima di inserirli nel descrittore. Quando il descrittore viene totalmente computato viene normalizzato per migliorarne la robustezza al contrasto ed inne viene assegnato al punto di interesse.

51


5.6

SURF Factory

Scopo E uninterfaccia che realizza il pattern Abstract Factory. Specializzazione La specializzazione dellinterfaccia SU RF F actory ` SU RF . e Questa implementazione prevede luso del pattern Singleton per il costruttore e permette di instanziare i corretti Detector e Descriptor. Struttura

Figura 5.6: Interfaccia SURF Factory e la nostra implementazione SURF.

Implementazione 1. createInstance

Parametri: img: PImage che ` convertita in immagine integrale prima di essere e assegnata a SURF; balanceValue: valore usato per il calcolo del determinante della matrice Hessiana; 52

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE threshold: valore usato per ltrare i valori dei determinanti della matrice Hessiana; octaves: numero di ottave che si vogliono computare; parent: PApplet nella quale si mostra loutput. Valore di ritorno: SURF: unica instanza della classe SURF, in accordo col pattern Singleton. Codice:p u b l i c s t a t i c SURF c r e a t e I n s t a n c e ( PImage img , f l o a t b al an c eV al u e , f l o a t t h r e s h o l d , i n t o c t a v e s , PApplet p a r e n t ) {

i f ( i n s t a n c e == null ) {

instance = new SURF( img , ba la n ce V al ue , t h r e s h o l d , o c t a v e s , p a r e n t ) ;

} else {

i n s t a n c e . s e t I n t e g r a l I m a g e ( img ) ; instance . setBalanceValue ( balanceValue ) ; instance . setOctaves ( octaves ) ; instance . setThreshold ( threshold ) ;

}

return i n s t a n c e ;

53

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE}

p u b l i c s t a t i c SURF c r e a t e I n s t a n c e ( PImage img , f l o a t threshold , i nt octaves , PApplet p a r e n t ) {

i f ( i n s t a n c e == null ) {

i n s t a n c e = new SURF( img , t h r e s h o l d , o c t a v e s , p a r e n t ) ;

} else {

i n s t a n c e . s e t I n t e g r a l I m a g e ( img ) ; instance . setOctaves ( octaves ) ; instance . setThreshold ( threshold ) ;

}

return i n s t a n c e ;

}

Applicazione del pattern Singleton. Il metodo statico ritorna unistanza della classe assicurandosi che sia lunica. Il metodo presenta due versioni, dove la prima ore la possibilit` di settare anche il valore di bilanciamento a del determinante dellHessiana, che altrimenti ` posto di default a 0.9 come e proposto in 1.2 nella (1.6).

54

CAPITOLO 5. IMPLEMENTAZIONE DELLE INTERFACCE 2. createDetector

Parametri: nessuno Valore di ritorno: Detector: Detector scelto in questa implementazione. Codice:public Detector createDetector () {

return new F a s t H e s s i a n ( i n t e g r a l I m a g e , imgWidth , imgHeight , ba l an ce V al ue , threshold , octaves , parent ) ;

}

Questo metodo viene usato per ottenere il corretto Detector. Nella nostra implementazione, si ritorna un Fast Hessian costruito sulla base dei parametri passati allatto della creazione di SURF. 3. createDescriptor

Parametri: nessuno Valore di ritorno: Descriptor: Descriptor scelto in questa implementazione.

55


Codice:p u b l i c D e s c r i p t o r c r e a t e D e s c r i p t o r ( A r r a y L i s t interest points ) {

return new SURF Descriptor ( i n t e r e s t p o i n t s , i n t e g r a l I m a g e ) ;

}

Questo metodo viene usato per ottenere il corretto Descriptor. Nella nostra implementazione, si ritorna un SURF Descriptor costruito sulla base dei parametri passati allatto della creazione di SURF. I rimanenti metodi sono semplicemente i vari Getters e Setters che non hanno bisogno di ulteriori spiegazioni.

56

Capitolo 6 RisultatiIn questa sezione abbiamo testato la nostra libreria SURF usando il dataset dimmagini forniti da Kristian Mikolajczyk [3]. Questo dataset contiene pi` u sequenze di immagini sulle quali sono presenti trasformazioni geometriche e fotometriche come riscalatura, rotazione, cambio di luminosit` e compressione JPEG a (Figura 6.2). Il criterio usato per valutare la performance dellindividuatore dei Punti di Interesse ` la ripetibilit`. Questa ` unimportante propriet` e si riferisce alla facie a e a lit` del punto ad essere individuato sotto varie manipolazioni dellimmagine. Pi` a u in dettaglio, si misura la percentuale di corrette corrispondenze geometriche in immagini della stessa scena, sotto per` dierenti condizioni. La corretta geomeo tria si riferisce al fatto che il punto ` localizzato nella stessa zona dellimmagine e e pu` essere misurata in vari modi. Il modo pi` semplice ` quello di controllare la o u e corrispondenza ad occhio, ma questo metodo pecca ovviamente di precisione. Un metodo migliore, ed ` quello su cui ci siamo basati per i nostri test, ` di legare i e e punti nelle diverse immagini con unomograa.

x=H x

(6.1)

Qui H ` una matrice di omograa 3x3 che mappa un punto in una prima immae 57

CAPITOLO 6. RISULTATI gine in una seconda. Il dataset ` provvisto di matrici di omograa estremamente e accurate (Figura 6.1), che mettono in relazione i punti della prima immagine di ogni sequenza con le successive. Nello specico, se si vuole mappare i punti della prima immagine di una sequenza nella seconda, si ha:

x2 = H1to2 x1

(6.2)

I test sono stati condotti con una tolleranza allerrore di individuazione crescente, a partire da un minimo di 1.5 pixel. Bay [1] conduce prove su pi` versioni u di Fast Hessian, denotate FH-9 e FH-15: la dierenza consiste nella dimensione del primo ltro della scale-space. Nel nostro caso, lunica versione testata ` quella e col ltro iniziale 9x9. Ci sono cinque dierenti cambiamenti sulle condizioni delle immagini (tra parentesi la sequenza relativa per i test): cambio di punto di vista (Grati ); cambio di scala (Boats); sfuocamento (Bikes); compressione JPEG (UBC ); cambio di luminosit` (Leuven). a Nella sequenza per il cambio di punto di vista, la camera si sposta da una vista frontale no ad inclinarsi di circa 60 alla ne della sequenza. Le sequenze per il cambio di scala e lo sfuocamento sono ottenute cambiando rispettivamente lo zoom ed il focus. Il fattore di scala cambia di circa un fattore 4. Il cambio di luminosit` ` introdotto variando lapertura della camera. Inne, la sequenza ae JPEG ` generata usando uno standard xv Image Browser con il parametro di e qualit` dellimmagine che varia dal 40% al 2%. Tutte le sequenze contengono a 6 immagini con una graduale trasformazione geometrica o fotometrica. Tutte le immagini sono di dimensione medie (circa 800 x 640 pixel). 58

CAPITOLO 6. RISULTATI

Figura 6.1: Il dataset di Kristian Mikolajczyk ` corredato da matrici di omograa e estremamente accurate. I risultati ottenuti sono mostrati di seguito. I test sono stati tutti condotti con un valore di soglia (Threshold ) di 640 ed un numero di ottave (Octaves) pari a 4. Tali valori si sono dimostrati quelli in grado di fornire le migliori prestazioni su tutte le sequenze. Si noti che per eetto della mancata implementazione dellinterpolazione per lindividuazione dei punti di interesse si ` persa linvarianza e al cambio di luminosit` e di scala. Pertanto le prestazioni dellalgoritmo sulle a sequenze Boats e Leuven risultano compromesse nelle ultime immagini. Per le altre sequenze, i risultati sono simili a quanto riportato in [1].

59


Figura 6.2: Dataset di test. Da sinistra verso destra: Grati con cambio di punto di vista, Bikes con sfuocamento, Boats con zoom e rotazione, Leuven con cambio di luminosit` e UBC con compressione JPEG. a

Figura 6.3: Accuratezza del detector sulla sequenza UBC.

60


Figura 6.4: Accuratezza del detector sulla sequenza Grati.

Figura 6.5: Accuratezza del detector sulla sequenza Boats.

61


Figura 6.6: Accuratezza del detector sulla sequenza Bikes

Figura 6.7: Accuratezza del detector sulla sequenza Leuven.

62


Figura 6.8: Matching dei Punti di Interesse su alcune immagini del dataset.

63

Capitolo 7 Utilizzo della libreriaForniamo di seguito alcuni passi necessari per lutilizzo della libreria SURF.

7.1

Installazione

La prima cosa da fare ` accedere tramite Web al sito uciale [4] per poter e scaricare lultima versione della libreria dalla sezione download. Una volta ottenuto larchivio decomprimerlo allinterno della sottocartella contributed del proprio sketchbook, su Linux solitamente ` /sketchbook, su Mac OS X e Windows ` e e la cartella Processing allinterno dei propri documenti. Qualora la sottocartella contributed non esistesse sar` necessario crearla. A questo punto riavviare Proa cessing. Un altro modo di procedere per un veloce test, ` trascinare la libreria, e cio` il le surf.jar direttamente sugli esempi forniti a corredo della libreria. e

7.2

Mercurial [9]

Per la clonazione del repository con Mercurial, forniamo direttamente il comando utile: hg clone https://[email protected]/surfprojectppm/processing-surf/

64

CAPITOLO 7. UTILIZZO DELLA LIBRERIA

7.3

Passi fondamentali

Schematicamente, elenchiamo i passi basi per il corretto uso della nostra libreria: (a) Importazione della libreria tramite il comando import.surf.*; (b) Denizione dei parametri per il funzionamento di SURF: il valore di threshold, il fattore di bilanciamento del determinante, il numero di ottave, lArrayList per i punti di interesse; (c) Caricamento dei pixel dellimmagine da analizzare con loadpixels() ; (d) Creazione dellinstanza SURF con createInstance(...) ; (e) Creazione del Detector (createDetector()), generazione dei punti di interesse (generateInterestPoints()), creazione del Descriptor (createDescriptor(...)) e generazione dei descrittori (generateAllDescriptors());

7.4

Esempi Processing

Forniamo di seguito il codice per uno dei due esempi a corredo della libreria, con in evidenza i passi riportati nella precedente sezione:

65

CAPITOLO 7. UTILIZZO DELLA LIBRERIA Esempio graco - GraphicExample

Codice:

Figura 7.1: GraphicExample.

66

Capitolo 8 Sviluppi futuriLa libreria, come aermato in 3.1 a pagina 14, risulta strutturalmente completa. Tuttavia, vi sono alcuni punti su cui poter lavorare. Sicuramente, ` nostra intenzione ranare lindividuazione dei punti tramite lue tilizzo dellinterpolazione tramite polinomio di Taylor 3D: ci` dovrebbe conferire o ai punti di interesse una maggiore robustezza al cambio di luminosit` e al cambio a di scala, punti deboli della nostra implementazione. Altro aspetto omesso rispetto al progetto originale ` lorientazione del punto di e interesse: questo certamente rende pi` limitato il potere descrittivo del descritu tore, la cui nestra risulta sempre essere nella posizione neutrale parallela ai lati dellimmagine. Visti i buoni risultati comunque ottenuti con il nostro lavoro, la libreria si presta anche cos` come ` resa disponibile a piccole applicazioni di e carattere non commerciale.

67

Capitolo 9 Usi possibiliGrazie alle capacit` di matching prevista dal SURF si pu` ipotizzare un suo a o futuro utilizzo nel campo del controllo visuale nei robot industriali e non. In particolare ci si riferisce alla capacit` di un robot generico nellindividuazione, tramite a sensori, di oggetti nello spazio secondo predenite speciche, grazie alla quale ` possibile eseguire una stima della posa (posizione ed orientazione) dellorgano e terminale ed una successiva pianicazione del moto dello stesso. La nostra libreria ` stata usata per alcune semplici analisi video, ad esempio e per il riconoscimento di banner pubblicitari durante una gara di Formula 1. I test hanno evidenziato che, nonostante la nostra implementazione sia parziale, i risultati ottenibili sono comunque degni di nota. Si faccia riferimento al sito del nostro progetto [4] per maggiori dettagli e alcuni video dimostrativi.

68

Bibliograa[1] Herbert Bay, Tinne Tuytelaars, and Luc Van Gool. Surf: Speeded-up robust features. In 9th European Conference on Computer Vision, Graz, Austria, 2006. [2] Christopher Evans. OpenSURF. http://code.google.com/p/opensurf1/ [3] Kristian Mikolajczyk datasets http://www.robots.ox.ac.uk/vgg/research/ane/ [4] Processing-SURF http://processingsurf.altervista.org [5] Progetto Processing http://www.processing.org [6] Progetto Eclipse http://www.eclipse.org [7] Ant Plugin http://ant.apache.org/ [8] eUML2 Plugin for Eclipse http://soyatec.com/euml2/ [9] DCVS Mercurial http://www.selenic.com/mercurial/wiki/ [10] Bit Bucket http://www.bitbucket.org [11] JavaDoc http://java.sun.com/j2se/javadoc/

69

Documents

Processing SURF