Tesi di laurea triennale in ingegneria elettronica e informatica

1. Corso di Studi in Ingegneria Elettronica e Informatica
Curriculum Informatica
Sviluppo di un algoritmo in C++ per il
riconoscimento di immagini ricatturate
nell’ambito forense
Tesi di Laurea Triennale
Laureando:
Antonio PROCENTESE
Relatore:
prof. Alberto BARTOLI
Correlatore:
ing. Marco FONTANI
____________________________________
ANNO ACCADEMICO 2018-2019

2. 2
Indice
Introduzione............................................................................................................................................... 3
Il problema dell’autenticazione delle immagini e perché focalizzarsi sulla recapture detection .......... 4
Implementazione ed esempio di uso ....................................................................................................... 8
Implementazione................................................................................................................................... 8
Esempio di uso.....................................................................................................................................13
Realizzazione, dataset, test e risultati.....................................................................................................16
Conclusioni...............................................................................................................................................18
Appendice................................................................................................................................................19
Bibliografia ...............................................................................................................................................21

3. 3
Introduzione
Si definisce ricatturata una foto scattata ad un’immagine che è riprodotta su uno schermo o su
carta. In questa sede si studiano immagini di alta qualità ricatturate su LCD, non facilmente
rilevabili ad occhio nudo.
Il processo di ricattura è strettamente collegato alla creazione di foto fasulle: utilizzarle come fonte
di prova in sede giudiziaria può avere le più svariate conseguenze. Immagini falsificate infatti, a
meno che non se ne provi la manomissione, hanno potenzialmente lo stesso effetto di quelle
“vere”:
• rovinare la reputazione altrui;
• diffondere fake news;
• inscenare tradimenti mai avvenuti;
• …e molto altro.
Pertanto, è di notevole importanza garantire che quelle usate in tribunale siano originali e
autentiche.
Gli algoritmi già esistenti per il riconoscimento di un recaptured sono divisi in due categorie: da
una parte, quelli che vanno a ricercare le specifiche alterazioni causate dalla ricattura (sfocatura,
distorsioni tipo aliasing, colore, rumore, differenti artefatti da compressione JPEG); dall'altra, quelli
che vanno più semplicemente ad analizzare statistiche dell’immagine [1]. L’algoritmo oggetto di
questa tesi appartiene alla seconda categoria ed estrae i coefficienti di correlazioni dalle immagini,
una quantità che verrà approfondita nella sezione “Implementazione”.
Ma perché ricatturare? Non basta un software di editing per ritoccare le immagini? La questione è
presto chiarita: ogni modifica a un’immagine fatta tramite software lascia tracce nei metadati del
file stesso. Queste, una volta rilevate, sono sufficienti agli analisti forensi per decretare la non
ammissibilità della prova in tribunale. Un’immagine ricatturata, non necessitando di alcuna
ulteriore modifica successiva allo scatto, supererà tutte le analisi basate sui soli metadati.
È possibile schematizzare il lavoro svolto nei seguenti passi:
• Studio dell’articolo scientifico [1];
• Implementazione dell’algoritmo;
• Acquisizione dei dataset per i test;
• Addestramento del classificatore (Support Vector Machine);
• Test e conclusioni;
• Varianti dell’algoritmo proposto;
• Ulteriori test e conclusioni.
L’azienda dove è stato svolto il lavoro è Amped Software, situata in Area Science Park. Si occupa di
analisi e miglioramento di immagini e video in ambito forense. Più nel dettaglio, il componente
software in oggetto nasce con l’obiettivo di essere poi inserito come estensione di un prodotto già
esistente il cui scopo principale è quello di analizzare le immagini per valutarne l’originalità e
l’autenticità, concetti che verranno definiti nella prossima sezione.
Il lavoro è stato svolto su sistema operativo Windows 10, utilizzando come ambiente di sviluppo
Visual Studio 2017. Sono state principalmente sfruttate due librerie: OpenCV per l’elaborazione
delle immagini, creazione e addestramento del classificatore; wxWidgets per la gestione dei file.
Come linguaggio è stato utilizzato il C++ poiché è tra quelli usati nei software dell’azienda.

4. 4
Il problema dell’autenticazione delle immagini e perché focalizzarsi sulla
recapture detection
Un’immagine digitale è una ricchissima fonte di informazioni. Dai metadati e dal contenuto visivo
possiamo infatti conoscere:
• Quando e dove è stata scattata;
• Quale specifico dispositivo ha catturato quella foto;
• L’istantanea di un avvenimento.
Questo la rende una potenziale fonte di prova e, in quanto tale, ne vanno accertate l’originalità e
l’autenticità.
Un’immagine digitale si dice originale se la sequenza di byte che la compone corrisponde
esattamente a quella generata al momento dell’acquisizione, senza aggiunte o perdite. In altre
parole, il file immagine deve essere integro.
Un’immagine caricata su Facebook o Instagram non è originale, in quanto, a seguito dell’upload, i
server la ricomprimono, la scalano ed eliminano metadati, principalmente per ragioni di spazio. La
sequenza di byte della foto presente sul social network non è la stessa prodotta dal dispositivo;
pertanto non si tratta dell’originale. Se però, tra lo scatto e l’upload sul social network, il
fotogramma non ha subìto nessuna modifica esterna che ne abbia considerevolmente alterato il
contenuto mediante aggiunta o rimozione di informazioni, l’immagine si dice autentica.
Un’immagine si dice autentica se è un’accurata rappresentazione dello scenario originariamente
catturato.
Grazie ad anni di ricerca nel Multimedia Forensics [13], oggi esistono molti strumenti che
consentono di svelare le tracce lasciate nei metadati e nei pixel dell’immagine dai software di
fotoritocco. Si noti che la ricattura non falsifica nulla di per sé: però, se fatta con l’intento di creare
immagini falsificate, scattando cioè la foto a una foto manipolata, allora può rappresentare una
tecnica molto subdola e sottile di manomissione. Segue un esempio dove viene mostrato proprio
quanto detto.
Si confrontano di seguito due immagini: la prima, non originale né autentica, è ritoccata con
Photoshop; l’altra, originale ma non autentica, è la sua ricattura.

5. 5
Figura 1: fotografia ritoccata con Adobe Photoshop. L’immagine non è né originale (perché la sequenza di
byte della foto non corrisponde a quella generata dal dispositivo al momento dello scatto) né autentica (il
contenuto è stato alterato tramite software di editing: in particolare, è stato rimpiazzato il volto).
Da un’analisi sui metadati della foto modificata, si evince che un software di fotoritocco ha
modificato l’immagine. Abbiamo anche un altro importante dato: la data di creazione è diversa
dalla data di ultima modifica. In un fotogramma non falsificato, queste due date dovrebbero
coincidere.
Figura 2: analisi sui metadati effettuata con Amped Authenticate

6. 6
Si osservi adesso come la stessa analisi fatta sulla foto ricatturata, il cui contenuto cioè è non
autentico esattamente come quella appena vista, dà risultati completamente diversi.
Figura 3: ricattura della foto ritoccata di Figura 1. L’immagine è originale (non ha subito modifiche
successive allo scatto) ma non autentica (il volto è stato sostituito tramite Photoshop).
La tabella è pulita: nessun avviso è presente.
Figura 4: Analisi sui metadati effettuata con Amped Authenticate

7. 7
L’immagine in questione in effetti è originale: il flusso di byte è esattamente lo stesso generato
dalla fotocamera al momento dello scatto; da quel momento, è rimasto immutato.
Essa però non è autentica, in quanto il contenuto è stato ritoccato: l’immagine non è infatti una
rappresentazione fedele della scena originaria.
Viene infine riportata l’immagine originale e autentica, a completamento dell’esempio.
Figura 5: foto di partenza, originale e autentica.

8. 8
Implementazione ed esempio di uso
Implementazione
L’obiettivo dell’algoritmo [1] è quello di costruire un classificatore a cui fornire in input delle
informazioni:
• sufficientemente discriminanti, da cui si possa decretare l’appartenenza della foto all’una o
all’altra classe;
• che siano il più possibile indipendenti dal contenuto della stessa;
• Il cui costo computazionale sia ridotto.
Con lo scopo di confrontare l’algoritmo proposto ad uno già esistente [3], è stata fatta la scelta da
parte degli autori dell’articolo [1] di ridimensionare l’immagine di input ad una larghezza di 2048
pixel e poi convertirla in scala di grigi.
Per soddisfare l’indipendenza dal contenuto, si filtra l’immagine eliminando la componente a bassa
frequenza, assumendo al contempo che le informazioni di interesse siano nella parte ad alta
frequenza. A partire da un’immagine I di dimensione W x H (interi), vengono generate due
“immagini residue” ; esse sono ottenute rispettivamente sottraendo ad I una sua
versione filtrata con due filtri , rimuovendo infine dal risultato della sottrazione la prima
e l’ultima riga e colonna con la funzione “trim”. Sotto forma di equazione si ha:
Dove * è il simbolo di convoluzione matematica e indica l’applicazione del filtro all’immagine I e
= e =
sono i due filtri. Sottrarre a I la sua versione filtrata equivale ad applicare un filtro passa alto.
Terminata questa fase di “pulizia” del fotogramma, comincia l’estrazione: si “scansiona” l’immagine
mediante una matrice 5x5 mobile, partendo dall’estremità in alto a sinistra: lo scorrimento avviene
spostando suddetta matrice di una sola colonna ad ogni iterazione; quando si raggiunge l’estremità
di destra del fotogramma, si ricomincia da sinistra, scendendo questa volta di una riga. Chiamiamo
K il numero totale di queste sottomatrici. Di tutte queste, si seleziona solo il primo elemento e si va
a riempire un array. Si sarà così formato un vettore avente come componenti tutti e soli gli
elementi posizionati nella prima casella in alto a sinistra di ciascuna sottomatrice 5x5. Si ripete il
procedimento considerando questa volta però il secondo elemento, riempiendo così un secondo
vettore. Si prosegue allo stesso modo per gli altri elementi, fino ad ottenere 25 vettori per ciascuna
immagine residua, per un totale di 50 (siccome le residue sono due).

9. 9
Figura 6 [10]: scorrimento della matrice. La prima sottomatrice 5x5 è quella rossa; all’iterazione
successiva, viene spostata di una riga (matrice viola) ecc…
Infine, si calcolano i coefficienti di correlazione (CC) tra il vettore contenente gli elementi estratti
dalla casella centrale (terza riga, terza colonna) di ciascuna sottomatrice, denotato con e tutti
gli altri vettori , con i, j = {1,…,5} tramite la seguente formula:
Dove e sono rispettivamente la media degli elementi in , con i, j
Scomponendo questa formula in parti più piccole per poi rimetterle insieme, risulta agevole
scriverla sotto forma di codice avvalendosi di semplici funzioni.

10. 10
// calcola la media di un vettore
float meanV(const std::vector<short>& Vector)
{ float mean = 0;
for (int k = 0; k < Vector.size(); k++)
{
mean += Vector[k];
}
return mean / Vector.size();
//un controllo impedisce di chiamare la funzione se il vettore è vuoto,
//per evitare divisioni per 0.
}
//Calcola il numeratore tra un vettore (i,j) e il vettore centrale (3,3)
float numerator(const std::vector<short>& centralVector, const
std::vector<short>& currentVector)
{
float sum = 0;
float centralMean = meanV(centralVector);
float meanCurrent = meanV(currentVector);
for (int k = 0; k < currentVector.size(); k++)
{
sum = sum + ((centralVector[k] - centralMean) *
(currentVector[k] - meanCurrent));
}
return sum;
}
//calcola metà denominatore
float halfDenominator(const std::vector<short>& centralVector)
{
double result = 0;
float centralMean = meanV(centralVector);
for (int k = 0; k < centralVector.size(); k++)
{
result = result + pow((centralVector[k] - centralMean), 2);
}
return sqrt(result);
}
//calcola tutto il denominatore
float totalDenominator(const std::vector<short>& centralVector, const
std::vector<short>& currentVector)
{
return halfDenominator(centralVector) *
halfDenominator(currentVector);
}

11. 11
//calcola il coefficiente di correlazione
float correlationCoefficient(const std::vector<short>& centralVector,
const std::vector<short>& currentVector)
{
return numerator(centralVector, currentVector) /
totalDenominator(centralVector, currentVector);
}
Si precisa che i CC si calcolano per la singola immagine (ogni estrazione è indipendente,
fotogramma per fotogramma).
In definitiva, per entrambe le immagini residue sono calcolati 25 coefficienti di correlazione.
Si riportano ora due matrici contenenti rispettivamente:
• I coefficienti di correlazione medi estratti da un set di immagini originali;
• I coefficienti di correlazione medi estratti da un set di immagini ricatturate.
Figura 7 [11]: Coefficienti di correlazione relativi alle immagini, rispettivamente, single captured e
recaptured di uno dei dataset usato per testare l’algoritmo, l’ICL, la cui descrizione verrà fornita
nel capitolo “Realizzazione, dataset, test e risultati”.
Si notino:
• una ridondanza dei CC, per ciascuna delle due tabelle analizzate singolarmente:
tralasciando l’elemento centrale che vale sempre 1, ogni coefficiente è ripetuto due volte.
• L’effettiva caratteristica discriminante di tali coefficienti: considerandone il solo valore
assoluto, le immagini ricatturate presentano mediamente CC più alti rispetto agli altri.
Per eliminare la ridondanza si eliminano 12 elementi su 24. In più si rimuove, in quanto elemento
non discriminante, anche il valore centrale della matrice, che è sempre 1, essendo il CC tra il
vettore centrale e sé stesso. Rimangono dopo questa eliminazione 14 elementi da ciascuna delle
due immagini residue, ottenendo in definitiva 28 CC. Il vettore 28-dimensionale è il risultato del
procedimento sin qui descritto.
Per motivi di efficienza è stata fatta la scelta dall’autore di questa tesi di estrarre direttamente i
vettori di interesse, senza sprecare risorse per il calcolo di vettori che poi non sarebbero stati
sfruttati.

12. 12
All’estrazione segue una fase di training, dove questi dati vengono forniti come input ad una SVM
(Support Vector Machine). Sottoponendo vettori presi da single captured images e vettori presi da
recaptured images, l’obiettivo è addestrare la macchina in modo che possa poi classificare
autonomamente nuove immagini.
“A Support Vector Machine (SVM) is a discriminative classifier formally defined by a separating
hyperplane. In other words, given labeled training data (supervised learning), the algorithm
outputs an optimal hyperplane which categorizes new examples.” [2]
Per la SVM è stato scelto un kernel di tipo gaussiano (RBF – Radial Basis Function) [1]. I parametri C
(della SVM) e Gamma (del kernel) sono scelti automaticamente da OpenCV: l’utente si limita a dare
un minimo e un massimo e la scelta avviene automaticamente. Più precisamente, Il training set
viene separato in due parti chiamate “train” e “validation”. Si addestra la SVM (usando solo il train)
con tante combinazioni possibili di C e gamma comprese nell’intervallo definito dall’utente e se ne
verifica l’accuratezza sul validation. Infine viene scelta la coppia C-gamma che ha ottenuto la
migliore accuratezza, e con questa coppia si addestrerà definitivamente la SVM usando l’intero
training set.
Si osservi che la SVM in questione, per funzionare, non “vede” immagini ma solo vettori, sia nella
fase di training sia nella fase di test: per quello che è lo scopo, ogni fotogramma è descritto
completamente da un vettore 28-dimensionale contenente i coefficienti di correlazione.
Quella di test è l’ultima fase: in questo stadio, verranno sottoposti nuovi vettori 28-dimensionali
alla macchina, che dovrà poi classificarli a seconda del valore dei CC, basandosi su quanto appreso
nella fase precedente.
La scelta di operare nel dominio dei pixel senza passare per le trasformate, ha l’obiettivo di
mantenere un costo computazionale ridotto [1]. L’algoritmo descritto impiega meno di 3 secondi
per immagine per il calcolo dei CC. La fase di training può variare da pochi minuti a qualche ora, in
base alla scelta di alcuni parametri. La fase di test è immediata.
Sono state sviluppate dall’autore della tesi diverse varianti dell’algoritmo, con l’intenzione di capire
come variano le prestazioni conseguentemente. Nella sezione “Realizzazione, Test e Risultati”, si
discuteranno i risultati di tali varianti più nel dettaglio. Intanto, vengono qui presentate:
• Una permette di personalizzare il ridimensionamento, senza il vincolo di tenere la larghezza a
2048 pixel. La sezione successiva, “Esempio di uso” ne mostra il funzionamento.
• Una che omette il ridimensionamento; si mantengono larghezza e altezza originali.
• Un’altra ancora dove l’immagine viene tagliata anziché ridimensionata.
• L’ultima variante si distingue maggiormente dalle altre: non si estrae un solo vettore 28-
dimensionale da ciascun fotogramma, bensì n vettori (con n intero dispari) 28 dimensionali da
n sotto-immagini prese casualmente dall’immagine stessa. Viene utilizzato qui un approccio di
majority voting che funziona così: se in fase di test, presa una foto, la maggior parte dei blocchi
viene classificata come originale (rispettivamente, ricatturata) allora l’immagine intera verrà
etichettata come originale (rispettivamente, ricatturata). Esempio: se da un’immagine
scomposta in 25 blocchi, 13 di questi sono classificati recaptured e 12 single captured, allora
l’immagine nella sua totalità è classificata come recaptured. La scelta del numero dispari in
questa occasione è stata fatta per prevenire situazioni di incertezza (n/2 vettori appartenenti
ad una classe e n/2 all’altra).

13. 13
Esempio di uso
Scenario: si supponga di avere un set di foto originali e un set di foto ricatturate da usare in parte
per addestrare la SVM e in parte per testarla.
All’avvio, vengono richiesti degli input all’utente: la cartella dove sono salvate le immagini da cui si
intendono estrarre i coefficienti di correlazione e la larghezza desiderata per ridimensionare le
immagini. Non viene richiesta l’altezza in quanto la funzione usata per scalare l’immagine mantiene
il rapporto larghezza/altezza originario e quindi è automaticamente calcolato. Chiaramente,
maggiore è questo numero, più alto sarà il costo computazionale per l’estrazione. Per ogni
immagine, vengono indicate a schermo le dimensioni originali e quelle post ridimensionamento.
Dopo un paio di secondi, viene riportato il vettore 28-dimensionale calcolato. Questo si ripete per
tutte le foto presenti nella cartella di input.

14. 14
Una volta giunti alla fine, è nuovamente richiesto l’intervento dell’utente, che deve indicare la
cartella di destinazione per il salvataggio dei vettori appena estratti. Inserito il percorso, appare un
messaggio che indica il salvataggio del file.
Si eseguono questi passaggi per un totale di quattro volte, su quattro insiemi (disgiunti) di foto
ricatturate ed originali. Per ciascuna delle due categorie, si dispone infatti di un training set e di un
test set.
Durante la fase di training, si deve creare e addestrare la SVM: essa riceverà in input i vettori
ottenuti dai training set, il cui scopo è fornire esempi che permettano alla stessa di classificare le
immagini test in base a quanto appreso.
Una volta addestrata la macchina e scelta una destinazione nel file system per il classificatore,
avviene il suo salvataggio.

15. 15
Rimane da testare la SVM. Forniti come input il numero di immagini da testare, il percorso dei file
contenenti i vettori da classificare e quello della SVM precedentemente creata, vengono fatte le
cosiddette predictions sulle foto di test.
Vengono stampate a schermo gli errori e l’accuratezza, rispettivamente:
• Totali;
• sul solo set di immagini originali;
• sul solo set di immagini ricatturate.

16. 16
Realizzazione, dataset, test e risultati
Si presentano in questa sezione i dataset utilizzati, i principali risultati dell’algoritmo sviluppato e
quelli delle sue varianti.
Sono stati usati tre diversi dataset:
• ICL [3][4], realizzato nell’Imperial College of London, di cui è stata usata la sola parte
disponibile gratuitamente online, composta da oltre 2000 tra immagini ricatturate e non,
ad alta risoluzione e ad alta qualità.
• ROSE [5][6][7], realizzato nella Nanyang Technological University di Singapore, composta
da più di 5000 tra single captured e recaptured images, ad alta risoluzione. Le immagini
non ricatturate sono ad alta qualità, mentre quelle ricatturate presentano spesso degli
artefatti evidenti anche ad occhio nudo (effetto Moiré).
• VISION, realizzato nell’Università degli Studi di Firenze. Da qui sono state prese poche
centinaia di foto tra le migliaia disponibili, tutte single captured. Le loro ricatturate sono
state generate dall’autore della tesi.
Per i test effettuati, si è diviso il dataset destinando l’80% delle immagini alla fase di training e il
20% a quella di test. Sono stati registrati ottimi risultati sull’ICL a seguito dell’estrazione dei vettori
con resize rispetto a quelle senza resize e con ritaglio (99.14% di accuratezza complessiva delle
classificazioni, contro 86.11% e 84.62% rispettivamente). I test condotti singolarmente su ROSE e
VISION sono stati pressoché una replica di quanto ottenuto con l’ICL. Essi si definiscono test intra
dataset: il training set e il test set appartengono cioè allo stesso dataset.
Diversa la situazione inter dataset, cioè quella in cui la SVM è testata su un test set non
proveniente dal dataset di addestramento: qui le prestazioni sono calate considerevolmente,
presentando accuratezze da un minimo di 25.4% a un massimo di 59.8%.
La SVM sin qui ha dunque funzionato a dovere solo nel caso in cui le immagini test erano ben
rappresentate nel training, cosa peraltro già notata dagli autori dell’articolo [1]. Al fine di superare
questo limite e raggiungere buoni risultati indipendentemente dal set di addestramento, è stato
cambiato approccio: anziché estrarre i vettori 28-dimensionali dall’immagine intera, si sono prima
estratti piccoli blocchi presi casualmente dal fotogramma di partenza, e poi da questi ultimi sono
stati estratti i vettori. L’obiettivo di questa filosofia è stato provare a ridurre la dipendenza delle
classificazioni dalle caratteristiche globali dell’immagine, azzardando l’ipotesi secondo cui una foto
di un dataset ha sicuramente caratteristiche distinte dalla foto di un altro dataset, ma non è detto
che questo avvenga anche per blocchi piccoli. In fase di test, all’immagine da classificare nella sua
totalità viene assegnata la classe che è stata predetta per il maggior numero dei suoi blocchi
(majority voting approach). Quest’ultima variante, tuttavia, non ha dato i risultati inter-dataset
sperati (25.95% in media).
Si noti che anche avvalersi di dati misti ha premiato: una SVM addestrata sui tre diversi dataset
(ICL, ROSE, VISION) e poi testata sugli stessi, naturalmente mantenendo la separazione tra training
set e test set, ha dato un’accuratezza totale del 97.64%.
Si riporta una tabella in cui viene rappresentata l’accuratezza globale media dei principali test
effettuati provando diverse configurazioni. A conferma di quanto detto sopra, l’approccio con
resize su immagini intra dataset è quello che ha dato i risultati migliori.

17. 17
Overall accuracy INTRADATASET INTERDATASET
Resize 98.78% 42.53%
Original size 90.77% -
Crop 83.29% -
Majority voting 88.75% 25.95%
Tabella 1: Una breve panoramica sui risultati dei test
Alla luce dei risultati ottenuti, cioè ottime prestazioni nei test intra-dataset ma scarse nei test
inter-dataset, è ragionevole sospettare che le feature utilizzate non catturino solamente
caratteristiche introdotte dal processo di ricattura, ma anche altre proprietà delle immagini che
restano coerenti all’interno di uno stesso dataset variando invece tra dataset diversi.

18. 18
Conclusioni
L’obiettivo di questa tesi di laurea era implementare e testare l’algoritmo [1] in un linguaggio che
fosse tra quelli utilizzati per i software prodotti da Amped, il C++. Quest’ultimo è stato raggiunto
con successo. Idealmente, per avere un quadro complessivo della situazione, questo lavoro
avrebbe dovuto rappresentare solo un primo passo per la successiva aggiunta di questo
componente in Amped Authenticate, software per la verifica di integrità e autenticità di immagini
digitali; aggiunta che non è avvenuta per quanto detto nella sezione precedente: è stata
riscontrata, in fase di test, un’eccessiva dipendenza delle classificazioni della SVM dal training set.
Nemmeno la variante dell’algoritmo fondata sul majority voting ha attenuato l’effetto
indesiderato, fallendo nell’intento di trovare una generalizzazione delle predizioni.
Considerando le fasi di:
• Estrazione dei vettori 28-dimensionali;
• Training;
• Test,
Sono state scritte in totale ~650 righe di codice per lo sviluppo dell’algoritmo originariamente
proposto. L’ultima variante, nel caso di estrazione dei CC da 25 sotto-immagini, supera le 2000.
Sono stati impiegati in totale circa 3 mesi di lavoro per completare il tirocinio. La fase su cui è stato
investito più tempo è senza dubbio quella di test.
Mi ritengo molto soddisfatto del lavoro svolto sotto più punti di vista. È stata un’occasione per
imparare un linguaggio per me nuovo, il C++ anche integrato con diverse librerie. Prima avevo solo
una vaga idea di cosa fosse una libreria; toccarle con mano mi ha dato modo di arricchire le mie
competenze, anche perché ho scoperto cosa vuol dire consultarne la documentazione. In più, mi
sono reso conto dell’importanza del lavoro di squadra applicato questa volta non in un contesto
accademico ma lavorativo: senza il team Amped, che è sempre stato disponibile ad ascoltare i miei
dubbi e a chiarirli, questo lavoro non sarebbe stato fatto. A loro va tutta la mia gratitudine.

19. 19
Appendice
Si inseriscono in appendice delle informazioni di base non esaustive, con l’intento di
accompagnare il lettore ad una comprensione più chiara della sezione “Implementazione”.
• Per il calcolatore, l’immagine non è altro che una matrice di dimensione NxM (interi) dove
ciascun elemento è un numero che indica il valore del pixel. Nelle immagini a colori le tabelle
sono 3, una per ciascun canale di colore (R, G, B). Il passaggio in scala di grigi fatto all’inizio
implica che il numero di canali nel caso in oggetto sia soltanto uno, quindi l’immagine da cui si
estraggono i dati è descritta da una sola tabella.
• Il filtro è una sorta di “griglia” che si applica singolarmente a ciascun pixel della tabella.
L’effetto di è quello di trasformare il pixel nella media dei pixel che lo affiancano,
mentre l’effetto di nella media tra quello sopra e quello sotto. Questo spiega il perché
della funzione trim: dopo la sua applicazione, tutti i pixel su cui viene applicato il filtro hanno
effettivamente dei pixel che lo affiancano. Si osservi ad esempio che senza questo passaggio, il
primo pixel posizionato nella prima riga e prima colonna dell’immagine di partenza, non ne
avrebbe un altro alla sua sinistra.
Figura 8 [8]: immagine di esempio di cui verrà osservata da vicino una regione.
• Per chiarire ulteriormente quanto detto sopra, si osservi adesso una regione da molto vicino
della figura 6: supponendo di ingrandire lo specchietto del veicolo, ci si trova di fronte una
tabella del genere.

20. 20
Figura 9: "lente di ingrandimento" su una regione di figura 8
Chiarito come un calcolatore percepisce un’immagine, dovrebbe essere ora più chiaro il
funzionamento della scansione effettuata con la matrice 5x5.
• Infine, si riporta il Dropbox link al file contenente i risultati dei test:
https://www.dropbox.com/s/d2dx76argjyjsjo/dati%20test.xlsx?dl=0

21. 21
Bibliografia
[1] Wang, K., “A simple and effective image-statistics-based approach to detecting recaptured
images from LCD
screens”, Digital Investigation (2017), https://doi.org/10.1016/j.diin.2017.10.001
[2] https://docs.opencv.org/2.4/doc/tutorials/ml/introduction_to_svm/introduction_to_svm.html,
sito web visitato in data 03/09/2019.
[3] T. Thongkamwitoon, H. Muammar and P. L. Dragotti, "An image recapture detection algorithm
based on learning dictionaries of edge profiles", IEEE Transactions on Information, Forensics and
Security
[4] H. Muammar and P.L. Dragotti, “An Investigation into Aliasing in Images Recaptured from an
LCD Monitor using a Digital Camera”, IEEE Int. Conf. on Acoustics, Speech and Signal
Processing(ICASSP), Vancouver, Canada, May 2013.
[5](Portions of) the research in this thesis work used the ROSE Recaptured Image Database made
available by the ROSE Lab at the Nanyang Technological University, Singapore.
[6] H. Cao and A.C. Kot, "Identification of Recaptured Photographs on LCD
Screens," in Proc. of ICASSP, pp. 1790-1793, 2010
[7] H. Cao, "Statistical Image Source Model Identification and Forgery Detection", PhD thesis,
Nanyang Technological University, 2010
[8]https://docs.opencv.org/master/d6/d6d/tutorial_mat_the_basic_image_container.html, sito
web visitato in data 02/09/2019
[9]https://www.bogotobogo.com/OpenCV/opencv_3_tutorial_mat_object_image_matrix_image_c
ontainer.php sito web visitato in data 02/09/2019
[10]http://1.bp.blogspot.com/8pku5HeFCdU/UT1Rej85ZI/AAAAAAAAknM/QAqMG5MXEkk/s1600/
PIXEL_ART_TABLE.png, sito web visitato in data 02/09/2019 da cui è stata scaricata l’immagine,
rielaborata con il software Amped Replay
[11] Figura presa dal paper [1] e modificata con Amped Replay.
[12] Amped Software, http://www.ampedsoftware.com per l’utilizzo di Amped Authenticate e
Amped Replay per l’elaborazione di varie immagini presenti in questo documento.
[13] Korus, Paweł. "Digital image integrity–a survey of protection and verification
techniques." Digital Signal Processing 71 (2017): 1-26.