UNIVERSITATEA TEHNICA DIN CLUJ-NAPOCA

FACULTATEA DE ELECTRONICA, TELECOMUNICATII SI

TEHNOLOGIA INFORMATIEI
Specializarea Tehnologii şi sisteme de Telecomunicaţii

Contribuţii la analiza şi implementarea unor

metode de extragere a caracteristicilor din
imagini în vederea clasificării lor
Lucrare de licenţă

PRESEDINTE COMISIE, DECAN,

Prof. dr. ing Monica Borda Prof.dr.ing. Marina ŢOPA

CONDUCATOR, ABSOLVENT,
Asist. ing. Anca Apătean Alexandru Mihu

2010
 UNIVERSITATEA TEHNICA DIN CLUJ-NAPOCA
FACULTATEA DE ELECTRONICA, TELECOMUNICATII SI
TEHNOLOGIA INFORMATIEI
CATEDRA DE COMUNICAŢII

Titlul temei: Contribuţii la analiza şi implementarea unor metode

de extragere a caracteristicilor din imagini în vederea clasificării lor

Enunţul lucrarii de licenţă:

Proiectul trebuie să conţină metodologia de alegere a caracteristicilor extrase din imagini,
implementarea unei aplicaţii Matlab de extragere a trăsăturilor din imaginile bazei de date pentru
clasificarea acestora. Obiectivele sunt documentarea metodelor de extragere trăsături deja
existente, clasificarea imaginilor pe baza trăsăturilor extrase şi realizarea practică a unei aplicaţii
de extragere trăsături şi clasificare imagini.

Locul de executie: Laborator 211

Data emiterii temei: 20 februarie 2009

Termen de predare: 24 iunie 2010

ŞEF CATEDRĂ, ABSOLVENT,

Prof.dr.ing. Virgil DOBROTA Alexandru Mihu

CONDUCATOR,
Asist.ing. Anca Apătean
 FACULTATEA DE ELECTRONICĂ, TELECOMUNICAŢII ŞI TEHNOLOGIA INFORMAŢIEI

Declaraţia autorului

Subsemnatul declar prin prezenta că ideile, partea de implementare şi experimentală,

rezultatele, analizele şi concluziile cuprinse în această lucrare constituie efortul meu propriu, mai
puţin acele elemente ce nu-mi aparţin, pe care le indic şi le recunosc ca atare.

Declar de asemenea, că după ştiinţa mea, lucrarea în această formă este originală şi nu a mai fost
niciodată prezentată sau depusă în alte locuri sau altor instituţii decât cele indicate în mod expres
de mine.

În calitate de autor, cedez toate drepturile de utilizare şi modificare a lucrării de licenţă către
Universitatea Tehnică din Cluj-Napoca.

Cluj-Napoca, 24 iunie 2010

ABSOLVENT,
Alexandru Mihu
1. absolvent Mihu Alexandru Ioan
2. asist. ing. Apătean Anca

SINTEZA LUCRARII DE LICENŢĂ

Contribuţii la analiza şi implementarea unor metode de extragere a caracteristicilor

(trăsăturilor) din imagini în vederea clasificării lor
Imaginile digitale, costul redus de realizare şi stocare al acestora, precum şi utilizarea lor
în tot mai multe domenii ale ştiinţei şi ingineriei, au introdus o creştere a cererii de aplicaţii de
analiză şi clasificare a imaginilor cu o precizie cât mai mare şi într-un timp cât de poate de scurt.
Lucrarea urmăreşte extracţia de trăsături din imaginile ce compun baza de date pentru a
obţine o acurateţe de clasificare (KNN) cât mai mare. Extracţia trăsăturilor s-a realizat prin
metode deja existente, folosite în cadrul clasificatorului WND-CHARM. Acest clasificator face
parte din mediul OME (Open Microscopy Environment). Numărul de trăsături extrase a fost
redus prin renunţarea la metodele ineficiente de extragere în ceea ce priveşte performanţele de
clasificare la 318 atribute pe imagine faţă de 1024 atribute pe imagine folosite pentru formarea
vectorului de trăsături din cadrul clasificatorului WND-CHARM. Astfel, timpul de extragere al
trăsăturilor tuturor imaginilor din baza de date, precum şi timpul de clasificare au fost micşorate
semnificativ (de la 48 de ore la 3 ore şi 11 minute , respectiv de la 2 secunde la mai puţin de o
secundă).
Prin modificarea bazei de imagini aplicaţia realizată poate fi utilizată în probleme de
detecţie sau recunoaştere din diverse domenii.

ABSTRACT
Digital images, cheap costs of acquisition and storage, as well as increasing use in many
fields of science and engineering, introduces a demand of image analysis and classification with
high accuracy and lower classification time.
This thesis follows feature extraction from database images to obtain a high KNN
clasification accuracy. Feature extraction was achieved by existing methods used in WND-
CHARM classifier, which is part of the OME environment (Open Microscopy Environment).
Number of features per image have been reduced from 1024 attributes per image used in WND-
CHARM feature vector to 318 attributes per image, by removing the inefficient extraction
methods in terms of clasification performance. Thus, the time needed for feature extraction for
all database images and classification time was reduced significantly (from 48 hours to 3 hours,
respectively from 2 seconds to less than one second).
By changing the image database the application can be used in detection and recognition
problems in many field of science and engineering.
 CURRICULUM VITAE

Name and surname: Alexandru Mihu

Date of birth: 16th of November 1986

Studies:
 High School: Colegiul Național „Lucian Blaga”, Sebeş

Professional activity:
 Internship at RDS & RCS S.A., technical advisor

Technical Knowledge:
 Advanced PC operating and programming skills:
Microsoft Windows and Office suite; Pascal , FoxPro, C , C++ , C# , embedded C,
Java.
 Electronical and mechanical CAD skills:
OrCAD suite , AutoCAD

Known languages:
 English: Writing, Reading, Speaking: Very Good
 German: Writing: Acceptable, Reading: Acceptable, Speaking: Acceptable

Contact address:
Address: Str.Valea Frumoasei 5C/8, Sebeş, Alba
Telephone: 0746 041 672
E-mail address: mihu_alexandru_ioan@yahoo.com

I the undersigned, Alexandru Ioan Mihu, declare that all the data in this Curriculum Vitae
can be used by The Faculty of Electronics, Telecommunications and Information Technology of the
Technical University of Cluj-Napoca, for promotional pourposes and professional orientation, in the
following conditions:

 Without prior consult

 After prior consult
 I do not agree
 Cuprins

1. Stadiul actual............................................................................................................................... 1
2. Fundamentare teoretică .............................................................................................................. 2
2.1. Introducere ......................................................................................................................... 2
2.2 Transformata Wavelet continuă şi discretă........................................................................ 3
2.2.1 Transformata Wavelet continuă ................................................................................. 3
2.2.2 Transformata Wavelet discretă .................................................................................. 3
2.2.3 Familii de wavelet-uri:............................................................................................... 5
2.2.4 Aplicaţii ale wavelet-urilor ........................................................................................ 5
2.3 Transformata FFT............................................................................................................... 6
2.3.1 Definire transformată FFT......................................................................................... 6
2.3.2 Aplicaţii ale transformatei FFT ................................................................................. 6
2.4 Transformata Radon............................................................................................................ 6
2.4.1 Definirea transformatei Radon .................................................................................. 7
2.4.2 Aplicaţii ale transformatei Radon .............................................................................. 7
2.5 Caracteristicile Tamura ...................................................................................................... 8
2.5.1 Granularitatea............................................................................................................ 8
2.5.2 Contrastul................................................................................................................... 8
2.5.3 Direcţionalitatea ........................................................................................................ 8
2.6 Polinoamele Zernike............................................................................................................ 9
2.6.1 Definirea polinoamelor Zernike................................................................................. 9
2.6.2 Aplicaţii ale polinoamelor Zernike........................................................................... 10
2.7 Histograme multiscalare ................................................................................................... 10
2.8 Filtre orientate în patru direcţii pentru obţinerea "primelor 4 momente"........................ 10
2.9 Algoritmul KNN................................................................................................................ 10
2.9.1 Avantajele algoritmului KNN................................................................................... 11
2.9.2 Dezavantajele algoritmului KNN ............................................................................. 12
2.10 Fişiere MEX (MEX-files)................................................................................................. 12
3. Implementarea soluţiei adoptate ............................................................................................... 13
3.1 Baza de imagini ................................................................................................................. 14
3.2 Metoda de extragere a caracteristicilor............................................................................ 15
3.2.1 Metoda de extragere a caracteristicilor din WND-CHARM.................................... 17
 3.2.2 Metoda de extragere a caracteristicilor în lucrarea de faţă.................................... 18
3.2.3 Evaluarea trăsăturilor în Weka............................................................................... 21
3.3.4 Evaluarea trăsăturilor în Matlab ............................................................................. 22
3.3 Determinarea parametriilor transformatei Wavelet ......................................................... 23
3.4 Modul de împărţire a datelor pentru învăţare şi testare................................................... 24
3.5 Îmbunătăţirea performanţelor........................................................................................... 25
3.5.1 Reducerea numărului de trăsături extrase din fiecare imagine…………………….35
3.5.2 Transformarea aplicaţiei într-un executabil ............................................................ 27
3.6 Interfaţa grafică a aplicaţiei ............................................................................................. 27
3.6.1 Extragerea trăsăturilor ............................................................................................ 28
3.6.2 Clasificarea imaginilor ............................................................................................ 28
3.6.3 Testarea clasificatorului KNN şi cu alte imagini decât cele din baza de date ........ 28
4. Rezultate experimentale ............................................................................................................ 28
4.1 Rezultate experimentale Weka........................................................................................... 29
4.2 Rezultate experimentale din Matlab şi din aplicaţia executabilă
5. Concluzii.................................................................................................................................... 35
6. Bibliografie................................................................................................................................ 37
7. Anexe ......................................................................................................................................... 39
7.1 Anexa 1 .............................................................................................................................. 39
Codul Matlab al funcţiei de transformare Wavelet...................................................................... 39
7.2 Anexa 2 .............................................................................................................................. 39
Codul Matlab pentru obţinerea fişierului cu vectorul de trăsături............................................... 39
7.3 Anexa 3 .............................................................................................................................. 39
Codul Matlab al funcţiei de extragere trăsături ........................................................................... 39
7.4 Anexa 4 .............................................................................................................................. 41
Codul Matlab pentru obţinerea fişierului cu liniile vectorului de caracteristici permutate......... 41
Codul Matlab pentru funcţia prelucrarefisierIN........................................................................... 41
Codul Matlab pentru functia preiaDatelePtPrel........................................................................... 42
7.5 Anexa 5 .............................................................................................................................. 43
Codul Matlab pentru clasificarea KNN ........................................................................................ 43
7.6 Anexa 6 .............................................................................................................................. 44
Codul Matlab al aplicaţiei GUI .................................................................................................... 44
Codul Matlab pentru metodele de extragere folosite în aplicaţia GUI ........................................ 63
Codul Matlab pentru extracţia trăsăturilor din fiecare imagine în funcţie de metodele alese în
aplicaţia GUI................................................................................................................................. 64
 Lista de figuri

Figura 1.1 Schema procesului de recunoaştere şi clasificare automată a imaginilor ...................... 3

Figura 2.1 Arborele cu primele trei nivele de descompunere DWT(arborele Mallat) .................... 4
Figura 2.2 Arborele Mallat cu primele trei nivele de reconstrucţie ale semnalului original........... 4
Figura 2.3 Familii de wavelet (a) Haar (b) Daubechies4 (c) Coiflet1 (d) Symlet2 (e)Meyer(f)
Morlet(g) Mexican hat..................................................................................................................... 5
Figura 2.4 Cele două forme ale transformatei Radon- ecuaţia (7) şi (9)........................................ 7
Figura 2.5 Valorile Zernike în unitatea de disc ............................................................................... 9
Figura 3.1 Imagini din baza de date .............................................................................................. 14
Figura 3.2 Schema bloc a metodelor de extragere a trăsăturilor ................................................... 15
Figura 3.3 Schema de formare a vectorului de trăsături din cadrul WND-CHARM.................... 17
Tabel 3.1 Metode de extragere a trăsăturilor analizate ................................................................. 20
Figura 3.5 Schema de formare a vectorului de trăsături................................................................ 20
Figura 3.6 Structura fişierului ARFF la modul general................................................................. 21
Figura 3.7 Structura fisierului ARFF utilizat în acestă lucrare ..................................................... 21
Figura 3.8 Matricele de confuzie pentru învăţare, respectiv testare.............................................. 22
Figura 3.9 Transformata Wavelet a unei imagini.......................................................................... 24
Figura 3.10 Schema bloc a clasificării KNN................................................................................. 25
Figura 3.11 Schma bloc urmată de toolbox-ul deploytool ............................................................ 27
Figura 3.12 Interfaţa grafică a lucrării........................................................................................... 27
Figura 4.1 Matrice de confuzie Weka (numărul de vecini=1) ...................................................... 29
Figura 4.2 Matricele de confuzie pentru k=3 (a),.......................................................................... 29
Figura 4.3 Matricele de confuzie pentru setul de testare (k=1,3 şi 5) obţinute în Weka............... 30
Figura 4.4 Matricele de confuzie pentru setul de testare obţinute în Matlab ................................ 30
Figura 4.5 Graficul timpului de clasificare în funcţie de numărul de trăsături ............................. 31
Figura 4.6 Graficul timpului de clasificare în funcţie de numărul de trăsături ............................. 31
Figura 4.7 Graficul timpului de extragere coeficienţi în funcţie de numărul de trăsături ............. 32
Figura 4.8 Graficul acurateţii în funcţie de numărul de trăsături .................................................. 35
 Lista de tablele
Tabel 3.1 Metode de extragere a trăsăturilor analizate ................................................................. 20
Tabel 4.1 Rezultate obţinute în Matlab ......................................................................................... 33
Tabel 4.2 Rezultate obţinute prin transformarea aplicaţiei într-un executabil .............................. 34
 1. Stadiul actual

Stadiul actual în ceea ce priveşte recunoaşterea formelor şi clasificarea automată a

imaginilor este unul avansat, reuşindu-se dezvoltarea unor aplicaţii care au o acurateţe a
clasificării foarte ridicată şi un timp de clasificare sau de detecţie foarte bun (detecţie sau
clasificare în timp real), şi care încet-încet promit a se apropia ca performanţă de modul natural
cu care fiinţa umană tratează această problemă.
Imaginile digitale, stocarea ieftină şi utilizarea acestora în tot mai multe domenii ale
ştiinţei şi ingineriei, au introdus o creştere a cererii de aplicaţii de analiză şi clasificare a
imaginilor cu o precizie cât mai mare. Aceste aplicaţii includ teledetecţia, descrisă în [1],
recunoaşterea facială, despre care puteţi găsi informaţii în [2], [3] sau [4] şi clasificarea
imaginilor medicale şi biologice [5], [6], [7] sau [8].
Sistemele de vedere artificială sunt proiectate după modelul sistemelor biologice, în
special cel uman. În dezvoltarea unor astfel de sisteme ne lovim, de foarte multe probleme. Cea
mai importantă dintre ele este imposibilitatea de a reproduce în sistemele artificiale, modul
nostru de gândire. Pentru noi oamenii, recunoaşterea unui obiect se face cu uşurinţă, chiar dacă
acel obiect nu este văzut în întregime, dar în general nu putem să explicăm ştiinţific cum am
reuşit să realizăm recunoaşterea. Prin urmare, nu putem dezvolta un algoritm sau o tehnică de
inteligenţă artificială care descrie iterativ şi exact acest proces.
Deşi în ultimii ani au atras o atenţie deosebită, analiza şi clasificarea imaginilor sunt
deocamdată considerate probleme competitive în sistemele de prelucrare şi clasificare pe baza
conţinutului imaginilor (CBIR - Content Based Image Retrieval), datorită complexităţii
subiectului în ceea ce priveşte imaginile reale şi dificultatea de extragere cantitativă a trăsăturilor
de similitudine sau diferenţiere dintre imagini. Aceste trăsături pot include caracteristici de
culoare, textură sau formă, descriptori ce sunt obţinuţi global prin extragerea informaţiilor pe
baza mediei histogramelor de culoare (pentru caracteristicile de culoare), pe baza granularităţii,
contrastului şi directivităţii imaginilor (pentru caracteristicile de textură) şi pe baza trăsăturilor de
curbură, momente invariante, circularitatea şi excentricitatea imaginilor (pentru caracteristicile
de formă). Cu toate acestea, extragerea trăsăturilor din imagini se face diferit în funcţie de
detaliile particulare ale aplicaţiei şi performanţele dorite.
În lucarea de faţă sunt propuse mai multe metode deja existente de extragere a
caracteristicilor pentru formarea vectorului de trăsături şi clasificarea imaginilor pe baza
vectorului obţinut.
Scopul principal al acestei lucrări este testarea mai multor metode de extragere a
trăsăturilor, nu neaparat obţinerea unor performanţe superioare. Pentru a vedea eficienţa
metodelor de extragere s-a realizat clasificarea imaginilor pe baza vectorului de caracteristici
prin intermediul clasificatorului IBk din Weka (echivalentul KNN- k nearest neighbor) şi KNN
implementat în Matlab. Pentru realizarea acestor obiective m-am inspirat din mai multe referinţe,
dar cea mai semnificativă este metodologia de extragere a trăsăturilor pentru formarea vectorului
de caracteristici din cadrul clasificatorului WND-CHARM (Weighted Neighbor Distances using
a Compound Hierarchy of Algorithms Representing Morphology - distanţa ponderată dintre
vecini utilizând o ierarhie compusă de algoritmi morfologici). Pentru mai multe detalii a se
consulta [9].
Trăsăturile vectorului de caracteristici includ descompunerea polinomială (reprezentată
de polinoamele Zernike), statisticile pixelilor (media, deviaţia standard, oblicitatea, planitatea,
histograme multiscalare) şi caracteristicile de textură (contrast, granularitate şi direcţionalitate).
Aceste caracteristici au fost extrase din imaginile pe nivele de gri, precum şi din imaginile
rezultate în urma transformatelor Wavelet (a imaginii pe nivele de gri şi a transformatei FFT-
fast Fourier transform a imaginii pe nivele de gri). O altă transformată utilizată este transformata
Radon a imaginii pe nivele de gri, care este folosită pentru extragerea informaţiei spaţiale.
Metodele aplicate asupra imaginilor pentru formarea vectorului de trăsături fac parte din
metodologia descrisă în [9]. Contribuţia adusă la formarea vectorului de trăsături constă în

1
selectarea din varietatea de metode de extragere doar a celor care oferă o performanţă de
clasificare mai ridicată. Pentru o aplicare eficientă a transformatei Wavelet s-au stabilit valorile
parametrilor (familia de wavelet şi nivelul de descompunere wavelet). Celelate metode utilizate,
precum şi implementările lor în Matlab pot fi descărcate gratuit şi utilizate în scopuri ştiinţifice şi
de cercetare de pe site-ul: http://www.openmicroscopy.org.
Vectorul de trăsături este utilizat apoi pentru clasificarea imaginilor de test într-un set de
clase de imagini predefint (clasa maşini, pietoni, animale şi garbage) cu ajutorul utilitarului
Weka. Deoarece apelarea din Matlab a utilitarului Weka este foarte complicată şi datorită
necesităţii utilizării unui clasificator în interfaţa grafică realizată, s-a ales implementarea în
Matlab a unui algoritm de clasificare. Astfel, luarea deciziei asupra clasei imaginii test s-a
realizat cu algoritmul KNN. Din punct de vedere al evaluatorului s-a ales folosirea KNN
deoarece este un clasificator rapid, eficient şi uşor de implementat. Pentru a nu permite
clasificatorului să înveţe inclusiv ordinea de preluare a imaginilor (deoarece clasificatorul prelua
pe rând cele patru clase) s-a realizat permutarea imaginilor din vectorul de caracteristici.
Din punct de vedere aplicativ, lucrarea conţine o interfaţă grafică dezvoltată cu ajutorul
toolbox-ului GUIDE (Graphical User Interface Design Environment) din Matlab. Această
aplicaţie permite utilizatorului să selecteze diferite variante de formare a vectorului de trasături,
precum şi posibilitatea testării clasificatorului KNN cu alte imagini decât cele din baza de date.
Vectorul de trăsături poate avea, în funcţie de metodele alese, o dimensiune minimă de 72
caracteristici şi maximă de 318 caracteristici. Toate atributele sunt extrase pe baza imaginilor pe
nivele de gri, astfel informaţiile de culoare nefiind utilizate.

2. Fundamentare teoretică

2.1. Introducere

În realizarea unei aplicaţii de recunoaştere a formelor şi clasificare automată a imaginilor,

după cum se poate observa în figura 1.1, în general se parcurg urmatoarele etape:
a) preprocesarea imaginii - etapă în care se realizează îmbunătăţirea calităţii imaginilor prin
aplicarea unor algoritmi DIP (digital image processing).[10]
Deoarece imaginile din baza de date, formată pentru acestă lucrare, nu necesită alte
îmbunatăţiri ale calităţii, în acestă etapă s-a realizat doar conversia imaginilor color în imagini pe
nivele de gri. În multe situaţii pentru clasificarea imaginilor sunt extrase pe lângă trăsăturile de
textură şi de formă, şi cele de culoare. S-a renunţat la aceste caracteristici deoarece nu se poate
realiza o diferenţiere a claselor pe baza culorii.
b) extragerea atributelor sau descriptorilor de imagine - reprezintă etapa cea mai importantă
deoarece influenţează în mod direct performanţele de clasificare.[10]
Tipul trăsăturilor folosite în clasificare şi descrise în această lucrare se împart în trei
categorii: descompunere polinomială, statisticile pixelilor şi textura. În descompunerea
polinomială este generat un polinom ce aproximează imaginea în funcţie de gradul de fidelitate,
iar coeficienţii acestui polinom sunt utilizaţi ca descriptori ai conţinutului imaginii. Trăsăturile
de textură se referă la variaţia în intensitate între pixelii imaginii pentru diferite direcţii şi
rezoluţii. Statisticile pixelilor se bazează pe distribuţia pixelilor din imagine şi includ histograme
şi momente.
În această etapă, pentru extragerea trăsăturilor, asupra imaginilor s-a aplicat transformata
Wavelet (transformata Wavelet a imaginii pe nivele de gri şi a transformatei FFT a imaginii pe
nivele de gri), iar din rezultatele obţinute au fost extrase caracteristicile de statistică a
pixelilor("primele 4 momente", histogramele multiscalare) şi de textură (caracteristicile Tamura).
Din imaginile originale (imaginile pe nivele de gri), fără a aplica asupra acestora nici o
transformată, sunt extrase caracteristicile de statistică a pixelilor şi de textură menţionate mai
sus, precum şi cele de descompunere polinomială (polinoamele Zernike). Din vectorul de

2
trăsături mai fac parte şi rezultatele obţinute în urma transformatei Radon a imaginii pe nivele de
gri.
c)evaluarea atributelor sau descriptorilor - este o etapă în care sunt evaluate datele din vectorul
de caracteristici şi care are ca rezultat în mod obişnuit, o valoare numerică unidimensională sau
multidimensională (un vector), care relevă distanţa vectorului de trăsături faţă de graniţele
regiunilor sau faţă de "bornele de clasificare".[10]
Evaluarea atributelor s-a realizat cu ajutorul clasificatorului KNN, prin testarea
evaluatorului cu datele de învăţare.
d) clasificarea imaginii - este etapa care îmbină rezultatele măsurătorilor multiple anterioare, şi
totodată etapa finală.
Prin clasificare se stabileşte apartenenţa formei, obiectului sau imaginii - descrisă prin
vectorul de trăsături, la un setul de clase de imagini predefinite.[10]
Clasificarea imaginilor de test, precum şi stabilirea atributelor imaginilor care ne oferă cea mai
bună performanţă s-a realizat cu ajutorul algoritmului KNN.

Figura 1.1 Schema procesului de recunoaştere şi clasificare automată a imaginilor[10]

2.2 Transformata Wavelet continuă şi discretă

2.2.1 Transformata Wavelet continuă

Transformata wavelet continuă (CWT- continuous wavelet transform) este folosită la

împărţirea funcţiilor de timp continue în unde mai mici.
Ecuaţia transformatei wavelet continuă este următoarea:

ଵ ௧ିఛ
XWT(τ,s)=
ඥ|ୱ|
∫ ‫ ∗ ߰ ∗ )ݐ(ݔ‬ቀ ௦ ቁ݀‫ݐ‬ (1)

unde x(t) este semnalul ce trebuie analizat, ψ(t) este wavelet-ul mamă sau funcţia de bază [11].
Toate funcţiile folosite în transformare sunt derivate din funcţia de bază prin translatare (shiftare)
şi scalare (dilatare sau compresie). Parametrul de translaţie τ se referă la locaţia funcţiei wavelet
în timpul parcurgerii semnalului, acesta corespunzând informaţiei de timp a transformatei.
Parametrul de scalare s este definit ca |1/frecvenţă| şi corespunde informaţiei de frecvenţă.
Scalarea fie dilatează (extinde) sau comprimă semnalul. În prelucrările de imagini, de obicei, se
doreşte compresia lor, pentru ca timpul necesar prelucrării să fie cât mai redus.
Pe o scară largă de frecvenţe joase semnalul este dilatat, fiind furnizate detaliile ascunse din
semnal, în timp ce pe o scară redusă (frecvenţe înalte) semnalul este comprimat, furnizându-se
informaţia globală referitoare la semnal.
Transformata Wavelet realizează convoluţia semnalului şi prelucrarea acestuia cu funcţia de
bază.

2.2.2 Transformata Wavelet discretă

Transformata Wavelet discretă (DWT- discrete wavelet transform) este o versiune

simplificată a transformării wavelet continuă, bazată pe codarea în sub-bandă. Avantajul acestei
transformate constă în simplitatea implementării, reducerea timpului de execuţie şi nivelul mai
scăzut de resurse necesare.
La transformata CWT, semnalele sunt analizate folosind un set de funcţii de baza care

3
realizează o simplă scalare şi translaţie. În cazul transformatei DWT, o reprezentare în domeniul
timp a unui semnal digital este obţinută prin utilizarea tehnicilor de filtrare digitală, semnalul
(imaginea) ce trebuie analizat fiind trecut prin filtre cu diferite frecvenţe de tăiere la nivele
diferite.
Transformata DWT este realizată prin filtrări trece jos şi filtrări trece sus succesive, ale unui
semnal discret în domeniul timp (figura 2.1).

Figura 2.1 Arborele cu primele trei nivele de descompunere DWT(arborele Mallat)[11]

În figura de mai sus, semnalul este notat cu x[n], unde n este un număr întreg, filtrarea trece jos
este realizată de blocul G0, la ieşirea lui obţinând aproximarea grosieră a coeficienţilor(notată
a[n]) , iar filtrarea trece sus este realizată de H0, la iesire obţinând informaţia detaliată (notată
d[n]).
Filtrele care împart banda în jumătate produc semnale ce ocupă doar jumătate din banda
de frecvenţă. Filtrarea şi descompunerea vor continua până când se ajunge la nivelul dorit,
numărul maxim de nivele de descompunere depinzând de lungimea semnalului (dimensiunea
imaginii).
Reconstrucţia semnalului original pe baza coeficienţiilor transformatei DWT este
procesul invers descompunerii (figura 2.2).

Figura 2.2 Arborele Mallat cu primele trei nivele de reconstrucţie ale semnalului original[11]

În Figura 2.2, d[n] reprezintă coeficienţii de detaliu ai semnalului, a[n] aproximările

grosiere, iar blocurile H1 şi G1 reprezintă filtrele trece sus, respectiv filtrele trece jos de sintetizare
a semnalului original.
Procesul de reconstrucţie al semnalului original continuă până când este atins numărul de
nivele de descompunere ale semnalului.

4
 Condiţiile ce trebuie îndeplinite pentru a avea o reconstrucţie perfectă sunt:

G0(-z)*G1(z)+H0(-z)*H1(z)=0 (2)

G0(z)*G1(z)+H0(z)*H1(z)=2‫ିݖ‬ௗ (3)
unde G0(z) şi G1(z) sunt filtrele trece jos de analiză, respectiv de sinteză, iar H1(z)şi H0(z) sunt
filtre trece sus de analiză, respectiv de sinteză[11].
Prima condiţie impune ca reconstrucţia să se facă fără alias, iar cea de-a doua condiţie
impune ca distorsiunile de amplitudine sa aibă valoarea egală cu 1.

2.2.3 Familii de wavelet-uri:

Există un anumit număr de funcţii de bază care pot fi folosite ca funcţii mamă pentru
transformata wavelet, dar pentru utilizarea eficientă a acestora, trebuie luate în considerare
detaliile particulare ale aplicaţiei care foloseşte wavelet-uri.
Principalele familii de wavelet-uri:

Figura 2.3 Familii de wavelet (a) Haar (b) Daubechies4 (c) Coiflet1 (d) Symlet2 (e) Meyer
(f)Morlet (g) Mexican hat [11]

Figura 2.3 ilustrează cele mai utilizate funcţii wavelet. Wavelet-ul Haar este unul din cele
mai vechi si simple wavelet-uri, de aceea orice discuţie despre wavelet-uri începe cu acesta.
Pentru mai multe detalii legate de principalele tipuri de wavelet-uri a se consulta [12].

2.2.4 Aplicaţii ale wavelet-urilor

Există o gamă largă de aplicaţii pentru transformarea wavelet, ele fiind utilizate în diferite
domenii, de la procesarea semnalelor până la domeniul biometriei.
Wavelet-urile au un rol important în compresia datelor, în vederea îmbunatăţirii
performanţelor de prelucrare a imaginilor (de compresie a imaginilor). FBI utilizează wavelet-
urile ca şi compresie standard a amprentelor, pentru stocarea lor în baza de date. Dintre
principalele tipuri de transformate aplicate imaginilor în vederea compresiei lor (ex. transformata
cosinus discretă, transformata Fourier discretă 2D etc.), transformata wavelet asigură asigură o
foarte bună rată de compresie.
Transformata Wavelet este aplicată în această lucrare pe imaginile pe nivele de gri,
precum şi pe imaginea obţinută în urma aplicării transformatei FFT asupra imaginii pe nivele de
gri. Parametrii transformatei, nivelul de descompunere şi familia wavelet, au fost stabiliţi
parcurgând următoarele etape:

5
a) extragerea trăsăturilor imaginilor din baza de date cu metoda I (vezi figura 3.5 pentru mai
multe detalii) pentru diferite nivele de descompunere wavelet (36) şi pentru diferite familii de
wavelet-uri.

b) clasificarea imaginilor pe baza vectorului de trăsături obţinut prin metoda de mai sus pentru a
observa care nivel, respectiv familie wavelet oferă o performanţă de clasificare cât mai bună.
Wavelet-urile sunt folosite atât în metoda I de extragere a trăsăturilor (reprezentată de metoda
descrisă mai sus), precum şi în metoda II de extragere a trăsăturilor (vezi figura 3.5)

2.3 Transformata FFT

FFT este abrevierea din limba engleză pentru fast Fourier transform (transformata
Fourier rapidă), fiind un algoritm eficient de calcul al transformatei DFT - discrete Fourier
transform (transformata Fourier discretă), precum şi a inversei sale IDFT (inverse discret Fourier
Transform).

2.3.1 Definire transformată FFT

FFT produce exact aceleaşi rezultate ca şi DFT, singura diferenţă fiind reprezentată de
rapiditatea transformatei FFT.
Fie ‫ݔ‬଴ , ‫ݔ‬ଵ, … , ‫ݔ‬ே ିଵ , numere complexe. Transformata DFT este definită de următoarea
formulă:
ܺ(݇ + 1) = ∑ே௡ୀ଴
ିଵ
‫ ݊(ݔ‬+ 1)ܹ ே௞௡ , k=0,1,… ,N-1 (4),
iar inversa ei IDFT este:
ଵ
ܺ(݊ + 1) = ே ∑ே௞ୀ଴
ିଵ
ܺ(݇ + 1)ܹ ேି௞௡ , n=0,1, … ,N-1 (5),
మഏ
unde j este unitatea imaginară, ܹ ே = ݁ି௝ ೙ şi N= lungime(x) [13].
Evaluând ecuaţia (4), observăm că aceasta necesită ܰ ଶ operaţii: sunt N ieşiri ܺ௞ şi fiecare ieşire
necesită o sumă de N termeni. Transformata FFT reprezintă orice metodă de obtinere a aceluiaşi
rezultat ca şi DFT în N log N operaţii. Pentru mai multe informaţii legate de transformata FFT şi
tipurile de algoritmi FFT a se consulta [13],[14] sau [15].
În lucrarea de faţă transformata FFT este utilizată în cadrul metodei II de extragere a
trăsăturilor, fiind aplicată asupra imaginii pe nivele de gri, iar apoi asupra acesteia se va aplica
transformata Wavelet (vezi figura 3.5 pentru mai multe detalii).

2.3.2 Aplicaţii ale transformatei FFT

Aplicaţiile transformatei FFT sunt urmatoarele:

- aproximări pe baza polinoamelor trigonometrice, compresia datelor (ex. MP3)
- analiza spectrală a semnalelor
- filtrare
- răspunsul în frecvenţă a unui sistem
- ecuaţiile parţial diferenţiale
- convoluţia în domeniul frecvenţă: - intercorelare
- multuplicarea de numere întregi mari
- multiplicarea simbolică a polinoamelor

2.4 Transformata Radon

Transformata Radon şi transformata Hough sunt strâns legate una de cealaltă, Radon fiind
o formă particulară a transformatei Hough.

6
 2.4.1 Definirea transformatei Radon

O reprezentare utilă a unei drepte este ecuaţia sa în coordonate polare:

‫ ߠݏ݋ܿݔ‬+ ‫( ߩ = ߠ݊݅ݏݕ‬6)
unde unde ߩ reprezintă distanţa dintre dreaptă şi origine, iar ߠ este unghiul dintre axa x pozitivă
şi dreapta ߩ [16].
Transformata Radon se defineşte ca integrală de-a lungul unei drepte inclinate cu unghiul ߠ faţă
de axa x pozitivă şi situată la distanţa ߩ faţă de origine [17]. Se notează în general cu g(ߩ, ߠ).
ାஶ
g(ߩ, ߠ)=∬ିஶ ݂(‫ݔ‬, ‫ ߠݏ݋ܿݔ(ߜ)ݕ‬+ ‫ ߠ݊݅ݏݕ‬− ߩ)݀‫(ݕ݀ݔ‬7)
unde ߜ reprezintă funcţia Dirac şi este ilustrată în [16] astfel:
+∞, ‫ = ݔ‬0

ߜ(‫ = )ݔ‬ቄ (8)
0 ,‫ ≠ݔ‬0

Figura 2.4 Cele două forme ale transformatei Radon- ecuaţia (7) şi (9) [17][18]

Ecuaţia ilustrată în [17]:

ାஶ
g(ߩ, ߠ)=∫ିஶ ݂(‫ ߠݏ݋ܿݏ‬− ‫ߠ݊݅ݏ ݑ‬, ‫ ߠ݊݅ݏݏ‬+ ‫(ݑ݀)ߠݏ݋ܿ ݑ‬9),
este echivalentă cu ecuaţia (2), fiind obţinută prin rotirea axelor de coordonate cu unghiul ߠ,
unde:
‫ ߠݏ݋ܿ ݔ = ݏ‬+ ‫ߠ݊݅ݏ ݕ‬ ‫ ߠݏ݋ܿݏ = ݔ‬− ‫ߠ݊݅ݏ ݑ‬
‫ = ݑ‬−‫ ߠ݊݅ݏ ݔ‬+ ‫ߠݏ݋ܿ ݕ‬ ‫ ߠ݊݅ݏ ݔ = ݕ‬+ ‫ߠݏ݋ܿ ݑ‬ (10)
Transformata Radon reprezintă o imagine ca un set de proiecţii de-a lungul diferitor
direcţii, realizând legătura dintre spaţiul de coordonate (x,y) şi spaţiul proiecţiilor (ߩ, ߠ).
Transformata Radon calculează proiecţia intensităţii pixelului pe o linie radială din
centrul imaginii la un unghi specificat. Aceasta este utilizată, de obicei, pentru extracţia
informaţiei spaţiale unde pixelii sunt corelaţi la un unghi specific.
În metoda de extragere caracteristici propusă, trăsăturile Radon sunt calculate pentru
unghiurile 0଴, 45଴, 90଴ şi 135଴. Apoi, fiecare set de valori rezultat este transformat într-o
histogramă cu trei benzi, rezultând astfel un vector cu 4x3=12 valori. Transformata Radon este
calculată pentru imaginea pe nivele de gri şi împreună cu "histogramele multiscalare", "primele 4
monemte " şi caracteristicile Tamura formează metoda III de formare a vectorului de trăsături
(vezi figura 3.5 pentru mai multe detalii).

2.4.2 Aplicaţii ale transformatei Radon

Transformata are aplicaţii în mai multe domenii cum ar fi:

- domeniul medical, în cazul tomografiei compiuterizate
- seismologie, în cazul reflexiei seismice
- ultramicroscopia ansamblurilor macromoleculare, cum sunt proteinele şi viruşii
- în rezolvarea ecuaţiilor hiperbolice parţial diferenţiale

7
- detecţia de formă

2.5 Caracteristicile Tamura

Dintre proprietaţile Tamura folosite în acest proiect se numară:

- granularitatea
- contrastul
- direcţionalitatea.
Aceste trăsături au fost selectate de Tamura, Mori şi Yamawaki pe baza experimentelor
psihologice.

2.5.1 Granularitatea se referă la distanţa dintre variaţiile spaţiale notabile a nivelelor de

gri. Procedura compiutaţională propusă, consideră diferenţele dintre valoarea medie a
semnalelor corespunzătoare ferestrelor de diferite dimensiuni care nu se suprapun, urmărind
paşii de mai jos :
1. Pentru fiecare pixel (x,y), calculează şase valori medii pentru ferestrele de dimensiunea 2k × 2k,
k=0,1,...,5 în jurul fiecarui pixel.
2. Pentru fiecare pixel, calculează diferenţa absolută Ek(x,y) dintre perechile valorilor medie ce
nu se suprapun în direcţiile: orizontală şi verticală.
3. Pentru fiecare pixel, caută valoarea lui k ce maximizează diferenţa Ek(x,y) în orice direcţie şi
setează dimensiunea cea mai buna Sbest(x,y)=2k.
4. Calculează trăsătura de granularitate Fcrs prin medierea Sbest(x,y) asupra întregii imagini.

2.5.2 Contrastul relevă modul în care nivelele de gri q, q=0,1,..., qmax, variază într-o
imagine g şi a căror distribuţie este direcţionată spre alb şi negru. Pentru definirea contrastului se
folosesc momentele centrale de ordinul al doilea şi cele normalizate de ordinul al patrulea,
reprezentate de varianţa standard - σ, respectiv indicele de aplatizare - α4:
‫ܨ‬௖௢௡ = ߪൗߙ௡ (11),
ସ
ఓర ଶ ௤೘ ೌೣ ଶ ௤ ௤೘ ೌೣ
unde ߙସ = ర (12); ߪ = ∑௤ୀ଴ (‫ ݍ‬− ݉ ) Pr ቀ ቁ (13); ߤସ = ∑௤ୀ଴ (‫ ݍ‬− ݉ )ସ Pr (‫ݍ‬/݃) (14) şi
ఙ ௚
m este media nivelelor de gri.[19]

2.5.3 Direcţionalitatea

Gradul de direcţionalitate este măsurat folosind distribuţia spectrală a muchiilor locale

orientate faţă de unghiurele direcţionale ale acestora. Soloditatea muchiei e(x,y) şi unghiul
direcţional a(x,y) sunt calculate folosind detectorul de muchii Sobel, aproximând "pixel-wise" x
şi derivata y a imaginii:

݁(‫ݔ‬, ‫ = )ݕ‬0.5(|∆௫(‫ݔ‬, ‫ |)ݕ‬+ ห∆௬ (‫ݔ‬, ‫)ݕ‬ห) (15)

ܽ(‫ݔ‬, ‫ି݊ܽݐ = )ݕ‬ଵ(∆௬ (‫ݔ‬, ‫)ݕ‬/∆௫(‫ݔ‬, ‫( ))ݕ‬16)

În ecuaţiile de mai sus Δx(x,y) şi Δy(x,y) sunt diferenţele pe verticală şi orizontală a nivelelor de
gri dintre pixelii vecini [19]. Diferenţele sunt măsurate utilizând următorii operatori fereastra de
dimensiune 3x3 [19]:
−1 0 1 1 1 1
−1 0 1 0 0 0
−1 0 1 −1 −1 −1
O histogramă Hdir(a) a valorilor direcţiei cuantizate a este construită prin numărarea
numărului de pixeli muchie care un anumit unghiul direcţional şi soliditatea muchiei mai mare
decât un prag predefinit. Histograma este relativ uniformă pentru imaginile fără o orientare

8
accentuată şi evidenţiază vârfurile pentru imaginile cu un grad al direcţionalităţii ridicat. Gradul
direcţionalităţii este legat de ascuţimea vârfurilor:

௡
೛೐ೌೖೞ ଶ
‫ܨ‬ௗ௜௥ = 1 − ‫݊ݎ‬௣௘௔௞௦ ∑௣ୀଵ ∑௔∈௪ ೛ ൫ܽ − ܽ௣ ൯ ‫ܪ‬ௗ௜௥(ܽ) (17),

În ecuaţia (17) ݊௣௘௔௞௦ este numărul de vârfuri, ap este poziţia vârfului p, wp este gama de
unghiuri atribuite vârfului p, r indică un factor de normalizare legat de nivelele de cuantizare ale
unghiului a, şi a este unghiul direcţional cuantizat (în modulo 180o).[19]

Aceste proprietăţi texturale Tamura sunt calculate pe imaginea pe nivele de gri astfel:
- 3 valori: contrastul, direcţionalitatea şi granularitatea
- o histogramă a granularităţii cu 3 benzi
Astfel, rezultă astfel un vector de caracteristici cu 6 valori.
Trăsăturile Tamura sunt utilizate în acestă lucrare în cadrul metodelor I, II şi III de
extragere a trăsăturilor (vezi Figura 3.5).

2.6 Polinoamele Zernike

Polinomele Zernike au fost dezvoltate la începutul secolului XX de către fizicianul

german Frits Zernike (faimos pentru invenţia microscopului fază-contrast, pentru care a câstigat
premiul Nobel pentru Fizică în 1953).

Figura 2.5 Valorile Zernike în unitatea de disc [20]

2.6.1 Definirea polinoamelor Zernike

Aceste caracterisitici Zernike sunt un set de polinoame definite pe unitatea de disc

(figura 2.5), ce pot fi reprezentate atât în sistemul cartezian (x,y), cât şi în coordonate polare
(r,). Cea mai utilizată formă, este descrisă în [21] ca fiind cea polară:
ܼ௝,௜௠ ௣௔௥ = √݊ + 1ܴ௡௠ (‫√)ݎ‬2 cos(݉ q) , ݉ ≠ 0 (18)
ܼ௝,௣௔௥ = √݊ + 1ܴ௡௠ (‫√)ݎ‬2 sin(݉ q) , ݉ ≠ 0 (19)
ܼ௝ = √݊ + 1ܴ௡଴(‫)ݎ‬, ݉ = 0 (20)
unde
(௡ି௠ )/ଶ (ିଵ)ೞ(௡ି௦)!
ܴ௡௠ (‫∑ = )ݎ‬௦ୀ଴ ೙శ ೘ ೙ష೘ ‫ݎ‬௡ିଶ௦(21)
௦!ቀ ି௦ቁ!ቀ ି௦ቁ!
మ మ
Valorile lui m şi n sunt întotdeauna întregi şi satisfac condiţile m≤n şi n-m=impar. Indexul j
reprezintă modul de ordonare al numerelor, fiind o funcţie j(m,n).
Condiţia de ortogonalitate pentru polinoamele Zernike ilustrată în [21] este:

∫ ܹ (‫ܼ)ݎ‬௝ ܼ௞݀ଶ‫ߜߨ = ݎ‬௝௞ (22),

unde:

9
 ଵ
, ‫ ≤ ݎ ݑݎݐ݊݁݌‬1

ܹ (‫ = )ݎ‬ቊగ (23)
0, ‫ > ݎ ݑݎݐ݊݁݌‬1

2.6.2 Aplicaţii ale polinoamelor Zernike

Baza acestor funcţii este definită pe o suprafaţă circulară, caracteristic planelor pupilelor
în procesarea clasică de imagini, pentru lungimi de undă optice şi inflaroşii, printr-un sistem de
lentile şi oglinzi cu un diametru finit.
Descompunera polinomială Zernike este utilizată în următoarele domenii:
- prelucrare optică, pentru a caracteriza erorile observate în analizele interferometrice, cu scopul
de a obţine performanţa dorită.
-optometrie şi oftalmologie, la descrierea devierii corneei sau lentilelor pentru o formă ideală
sferică, care au ca rezultat erori de refracţie.
- optica adaptivă, la înlăturarea distorsiunilor atmosferice. Aplicaţiile în acest domeniu sunt
astronomia IR (inflaroşu) sau vizuală şi pentru redarea imaginilor din satelit. De exemplu, unul
dintre factorii Zernike (pentru m=0 şi n=2) este denumit "de-focus". Prin cuplarea iesirii acestui
factor la un sistem de control, poate fi implementată o focalizare automată. [21]
Coeficienţii Zernike sunt valori complexe, în descrierea imaginilor folosindu-se valoarea
absolută a acestora. Polinoamele Zernike sunt aplicate asupra imaginii pe nivele de gri,
constituind metoda IV de extragere a trăsăturilor (pentru mai multe detalii vezi figura 3.5).

2.7 Histograme multiscalare

Pentru acest set de trăsături sunt calculate histograme cu un număr variabil de benzi
(3,5,7 şi 9), după modelul propus în [9]. Fiecare domeniu de frecvenţe corespunde unei
histograme diferite, şi astfel numărul variabil de benzi permite măsurarea conţinutului într-un
domeniu de frecvenţe foarte larg. Maximul histogramelor este folosit pentru normalizarea
vectorului de caracteristici rezultat, care are un număr de 1x24 elemente. Histogramele
multiscalare sunt aplicate asupra transformatei Wavelet, transformatei FFT şi asupra imaginii
originale (imagine pe nivele de gri) contribuind astfel cu un număr total de 3x24 elemente la
formarea vectorului de trăsături al imaginilor.
Histogramele multiscalare sunt utilizate în cadrul metodelor I, II şi III de formare a
vectorului de trăsături.(pentru mai multe detalii vezi figura 3.5)

2.8 Filtre orientate în patru direcţii pentru obţinerea "primelor 4 momente"

Pentru acest set de trăsături, imaginea este subdivizată într-un set de "dungi" în patru
orientări diferite (0଴, 90଴, +45଴ şi −45଴). "Primele 4 momente" (media, deviaţia standard,
oblicitatea şi planitatea ("kurtosis") ) sunt calculate pentru fiecare "dungă" şi fiecare set de
"dungi" este transformat într-o histogramă cu 3 benzi. Având astfel patru momente în patru
direcţii cu histograme cu trei benzi, rezultă un vector de trăsături care conţine 4x4x3=48
elemente.[9]
"Primele 4 momente" sunt utilizate, lafel ca şi histogramele multiscalare în cadrul
metodelor I, II şi III de extragere a trăsăturilor din imaginea originală.

2.9 Algoritmul KNN

KNN este abrevierea din limba engleză pentru K-Nearest Neighbor (cei mai apropiaţi k
vecini), fiind un algoritm de învaţare supervizat utilizat în special în problemele de clasificare.
Scopul acestui algoritm este acela de a clasifica un nou obiect pe baza atributelor sale în fincţie
de setul de date de antrenare cunoscut.

10
 Prin această tehnică, folosită în special pentru clasificarea datelor în mai multe posibile
clase, un obiect nou este clasificat pe baza majorităţii voturilor vecinilor săi, fiindu-i atribuită
clasa cea mai frecvent întâlnită printre cei “k” cei mai apropiaţi vecini.
Acei “k” cei mai apropiaţi vecini se aleg pe baza distanţei minime dintre obiect şi toate
celelalte obiecte din setul de date de antrenare (setul de date cunoscut).
Fiecare obiect este reprezentat în setul de date printr-un vector de trăsături, care în cazul
imaginilor poate să conţină caracteristici de formă, de textură sau de culoare.
Există mai multe tipuri de distanţe folosite pentru calculul distanţei minime dintre “noul
vector” şi “vectorii” din setul de date:
- distanţa euclidiană
- distanţa euclidiană standardizată
- distanţa city block (Manhattan)
- distanţa cosinus
- distanţa coeficientului de corelaţie (distanţa Pearson r)
- distanţa hamming
- distanţa Maholonobis
- distanţa Minkowski
- etc
Cea mai frecventă distanţă utilizată în cadrul acestui algoritm este distanţa euclidiană.
Fiind dată o matrice X de dimensiune [mxn], care conţine "m" vectori linie (vectorii de trasături
de dimensiune [1xn]) ‫ݔ‬ଵ, ‫ݔ‬ଶ,…, ‫ݔ‬௠ , unde ‫ݔ‬௞=(‫ݔ‬ଵ௞ , ‫ݔ‬ଶ௞ ,…, ‫ݔ‬௡௞ ), putem defini metricile (distanţele)
dintre două obiecte (doi vectori) oarecare ‫ݔ‬௥ şi ‫ݔ‬௦ (r,s=1m) după cum sunt ilustrate şi în [22],
astfel:
- distanţa euclidiană:
݀௥௦=ඥ(‫ݔ‬௥ − ‫ݔ‬௦)(‫ݔ‬௥ − ‫ݔ‬௦)ᇱ = ඥ ∑௡௜ୀଵ(‫ݔ‬௜௥ − ‫ݔ‬௜௦ )ଶ (24)

- distanţa euclidiană standardizată

݀‫ݏ‬௥௦=ඥ(‫ݔ‬௥ − ‫ݔ‬௦)‫ି ܦ‬ଵ(‫ݔ‬௥ − ‫ݔ‬௦)ᇱ , unde D este matricea diagonală, ce are ca elemente
dispersia vectorului ܺ௜=(‫ݔ‬௜ଵ, … , ‫ݔ‬௜௠ ), notată ݀௜ଶ, rezultând:
ଶ
(௫೔ೝି௫೔ೞ )
݀‫ݏ‬௥௦=ඨ ∑௡௜ୀଵ ቀ ቁ (25)
ௗ೔

- distanţa city block (Manhattan)

݀ܿ௥௦=∑௡௜ୀଵ|‫ݔ‬௜௥ − ‫ݔ‬௜௦| (26)

- distanţa cosinus
௫ೝ௫ೞᇲ
݀ܿ‫ݏ݋‬௥௦=ቆ1 − భ ቇ
భ (27)
(௫ೝ௫ೝᇲ)మ(௫ೞ௫ೞᇲ)మ

- distanţa coeficientului de corelaţie (distanţa Pearson r)

തതത
(௫ೝି௫ ത)(௫ೞି௫ ത)ᇲ
തതೞ
‫ݎ‬௥௦ =1 − ೝ
‫ݔ‬ത௥ത=∑௡௜ୀଵ ‫ݔ‬௜௥ (28)
, unde ത
ඥ(௫ೝି௫
തതത
ത)(௫ೝି௫
ೝ ത)ᇲඥ(௫ೞି௫
തതത
ೝ തതೞ
ത)(௫ೞି௫ ത)ᇲ
തതೞ
- etc, pentru mai multe tipuri de metrici a se consulta [22]
Pentru a întelege şi mai bine funcţionarea algoritmul KNN pe un exemplu numeric a se
consulta consulta [24].

2.9.1 Avantajele algoritmului KNN

Unul dintre avantajele sale este uşurinţa implementării, fiind unul dintre algoritmii de
clasificare cei mai uşor de înteles.

11
 O altă calitate a acestei tehnici este eficacitatea sa, în cazul în care, setul de date de
antrenare este afectat de zgomot (în special în cazul în care se foloseste ca metrică inversul
pătratului distanţei ponderate). Obţinerea distanţei ponderate se face prin ierarhizarea fiecărei
trăsături în funcţie de scopul propus. Astfel distanţa euclidiană ponderată va avea urmatoarea
expresie:
݀‫ݓ‬௥௦= ඥ ∑௡௜ୀଵ ‫ ݓ‬௜(‫ݔ‬௜௥ − ‫ݔ‬௜௦ )ଶ (29),
௡
unde ∑௜ୀଵ ‫ ݓ‬௜=1, iar ‫ ݓ‬௜ este ponderea atributului (caracteristicii) i [23] .
A nu se confunda ponderarea atributelor cu ponderarea distanţelor.
O metodă foarte întâlnită de ierarhizare a distanţelor, este aceea de a-i da fiecarui vecin o
pondere de 1/d , unde d este distanţa pâna la vecin. Astfel vecini mai apropiaţi vor avea o
contribuţie mai mare la clasificarea unui obiect. Studiile au aratat că ponderarea distanţelor nu
îmbunătăţeşte performanţele algoritmului KNN.

2.9.2 Dezavantajele algoritmului KNN

La aplicarea algoritmului KNN în practică ne lovim de următoarele probleme:

a)"Ce metrică utilizăm pentru performanţe cât mai bune?"
b)"Care este valoarea optimă pentru k?"
c)"Trebuie să folosim toate atributele sau numai anumite atribute ale obiectelor?"
Toate aceste probleme au ca efect cresterea timpului de clasificare.
Timpul de clasificare depinde în special de numărul de obiecte din setul de date. Pentru
seturile de date cu un număr foarte mare de obiecte este necesară o reducere a numărului de
atribute pentru fiecare obiect în etapa de preclasificare, prin alegerea unor puncte cheie care să
diferenţieze între ele cât mai bine posibil instanţele setului de date.
k optim se obţine prin testarea algoritmului de mai multe ori, modificând numărul de
vecini.
Costul de calcul este destul de mare, deoarece trebuie să calculăm distanţa dintre o noua
instanţa şi fiecare instanţă din setul de antrenare. Acest cost poate fi redus prin utilizarea metodei
"K-D tree".[25]
Pentru a vedea eficacitatea metodelor de extragere a caracteristicilor, în această lucrare s-
a folosit clasificatorul KNN. Am ales acest algoritm datorită simplităţii lui, a performanţelor
bune de clasificare, atât în ceea ce priveşte acurateţea cât şi a timpului de clasificare.

2.10 Fişiere MEX (MEX-files)

MEX este abrevierea din limba engleză pentru MATLAB Executable (executabile
Matlab). Fişierele MEX sunt subrutine dinamice realizate în mediile de programare C, C++ sau
Fortran, coduri sursă care compilate pot fi rulate din Matlab în acelaşi mod cum sunt rulate şi
fişierele M (M- files) sau orice altă funcţie care este deja implementată în Matlab. Funcţiile
externe de interfaţare realizează transferul de date între MEX- files şi Matlab, oferind totodată şi
posibilitatea de a chema funcţii Matlab din programele C, C++ sau Fortran.
Principalele motive de a creea în loc de un M-file un MEX- file sunt următoarele:
- abilitatea de a apela o gamă largă de rutine C, C++ sau Fortran deja existente direct din Matlab
fără a fi nevoiţi să le rescriem ca un M -files
- viteza de execuţie; putem rescrie programele care folosesc de exemplu bucle FOR ca şi MEX-
files pentru eficienţă. Pentru mai multe detalii legate de realizarea MEX- files a se consulta [26].
În această lucrare MEX- files sunt folosite pentru calculul polinoamelor Zernike ale unei
imagini, precum şi pentru implementarea clasificatorului KNN. Aceste MEX- files sunt realizate
de dezvoltatorii clasificatorului WND-CHARM, respectiv de Roger Jang şi pot fi descărcate
gratuit de pe site-urile:
http://www.openmicroscopy.org, respectiv http://mirlab.org/jang/matlab/toolbox/dcpr/.

12
 3. Implementarea soluţiei adoptate

Scopul lucrării de faţă este acela de a testa diferite caracteristici care să codeze cel mai
bine imaginile din baza de date şi nu neaparat clasificarea acestora. Totuşi, pentru a verifica
eficienţa metodelor de extragere a trăsăturilor s-a folosit clasificatorul KNN.
În general, un sistem de recunoaştere al obiectelor trebuie să:
1- extragă atributele care grupeză imaginile într-o anumită clasă şi diferenţiază imaginile din
clase diferite
2- să clasifice aceste atribute
3- să elimine alarmele false - de aceea avem clasa garbage
4- în cazul detecţiei obstacolelor să identifice clasa imaginii pe baza acestor atribute
5- să urmărească obiectele de-a lungul scenei rutiere până în momentul în care se pierd în afara
ei şi nu mai reprezintă nici un pericol (modul de "tracking" (urmărire)).
În această lucrare s-a presupus că obiectele sunt deja segmentate (detectate), baza de date
fiind formată din imagini care încadrează doar obiectele şi nu din scene întregi de mai multe
obiecte. Astfel, în această lucrare este tratat numai modul de extragere al atributelor pentru
clasificare, precum şi clasificarea obiectelor.
La început s-a încercat extragerea caracteristicilor din imagini numai pe baza
transformatei Wavelet. Imaginile din baza de date au diferite dimensiuni (unele ilustrează obiecte
mai apropiate având implicit dimensiuni mai mari- maxim 434x768 pixeli, altele obiecte mai
depărtate, având dimensiuni mai mici- minim 89x69 pixeli), iar pentru clasificare este necesar
obţinerea unui număr fix de caracteristici pentru fiecare imagine. Din această cauză, înainte de a
aplica transformata Wavelet asupra imaginilor este necesară redimensionarea lor la aceleaşi
valori. Rezultatele obţinute în urma clasificării KNN a imaginilor nu au fost satisfăcătoare. Din
acest motiv s-a renunţat la redimensionare şi s-a încercat găsirea unor metode de extragere a
trăsăturilor care prin aplicarea lor asupra imaginilor să returneze un număr fix de coeficienţi
indiferent de dimensiunea imaginii.
Sistemele de clasificare folosesc diferite caracteristici pentru definirea obiectelor din
imagini. Aceste caracteristici reprezintă şablonul (pattern-ul) obiectului, iar sabloanele obiectelor
care aparţin mai multor clase vor fi esenţiale pentru procesul de invăţare şi testare al sistemului.
Pentru obţinerea caracteristicilor s-au folosit o serie de transformări, combinaţii de transformări
şi de metode de extragere:
- transformata Wavelet
- transformata FFT
- transformata Radon
- caracteristicile Tamura
- histogramele multiscalare
- filtre orientate în patru direcţii pentru obţinerea "primelor 4 momente"
- polinoamele Zernike.
În pasul de clasificare, algoritmul de evaluare se bazează pe calculul de distanţe între
vectorii de caracteristici corespunzători obiectelor. Pentru a detecta şi a recunoaşte
caracteristicile altor obiecte noi, sistemul trebuie învăţat apriori cu aceste şabloane prin
intermediul caracteristicilor extrase. Sistemul odată învăţat, poate fi folosit doar pentru testare,
iar dacă se doreşte adăugarea de noi instanţe în setul de antrenare, se va mai trece încă o dată prin
etapa de învăţare. Astfel, au fost studiate metodele de extragere enumerate mai sus pentru
formarea setului de antrenare şi testare. Acestea sunt utilizate de clasificator (KNN) pentru a se
realiza recunoaşterea automată obiectelor.
În lucrare de faţă s-a utilizat algoritmul de clasificare KNN, datorită simplităţii
implementării şi al performaţelor bune de clasificare.

13
 3.1 Baza de imagini

Baza de imagini este construită din 800 de imagini color, împărţite în patru clase după
cum urmează:
- 200 de imagini cu maşini
- 200 de imagini cu pietoni
- 200 de imagini cu animale (câini, pisici, vaci, oi, cai)
- 200 de imagini alcătuind clasa "garbage".
Baza de date a fost preluată de pe internet din diferite baze de imagini disponibile gratuit
pe site-ul http://pascallin.ecs.soton.ac.uk/challenges/VOC/databases.html, deoarece nu a mai fost
creată până acum o astfel de bază de imagini. După cum se poate observa în figura 3.1 imaginile
au fost selectate manual şi au fost extrase doar obiectele de interes din acestea. Apoi imaginile au
fost transformate în imagini pe nivele de gri.
În figura de mai jos sunt ilustrate diferite imagini din fiecare clasă:

Figura 3.1 Imagini din baza de date

După ce caracteristicile au fost extrase din imagini, ele au fost introduse în clasificator
pentru a realiza clasificarea imaginilor în cele patru clasele. După cum se poate observa în figura
3.1, imaginile care alcătuiesc clasa garbage au fost obţinute din fundalul imaginilor celorlalte
clase. Această clasă este utilă la detectarea alarmelor false, când imaginea nu face parte din nici
una din clasele maşini, pietoni sau animale.
În general pentru crearea unei baze de imagini care să fie cât mai bună, sunt respectate
următoarele principii:

14
- toate imaginile să fie realizate cu aceleaşi procedee (să fie realizate cu acelaşi aparat de
fotografiat sau cameră de filmat)
- parametrii mijloacelor de captare a imaginilor să fie identici pentru toate imaginile
- să aibe un număr de imagini care să permită obţinerea unor rezultate de clasificare
satisfăcătoare.
Deoarece nu a mai fost creată o bază de imagini ca şi cea utilizată în lucrarea de faţă şi
realizarea unei astfel de baze de imagini necesită foarte mult timp, au fost folosite imagini care
fac obiectul altor baze de date. Bine înţeles că baza de imagini formată, nu este la fel de bună ca
cea care respectă principiile enumerate mai sus.

3.2 Metoda de extragere a caracteristicilor

După crearea bazei de imagini, s-a realizat extragerea caracteristicilor din imagini prin
intermediul diferitor transformate de imagini (transformata Wavelet, transformata FFT,
transformata Radon) şi alte moduri de extragere ("primele 4 momente", histograme multiscalare,
caracteristicile Tamura - granularitatea, contrastul şi direcţionalitatea, şi polinomurile Zernike).
După cum se poate observa în figura 3.2, aceste transformate şi celelalte procedee de
extragere a caracteristicilor enumerate anterior, sunt distribuite în patru metode de extragere a
caracteristicilor, astfel:

Figura 3.2 Schema bloc a metodelor de extragere a trăsăturilor

15
 Metodele de extragere a trăsăturilor, după cum se poate vedea în figura 3.2, au fost
denumite metoda I, metoda II, metoda III şi metoda IV pentru ca referirea la acestea să se
realizeze mult mai uşor.
Privind figura 3.2 se poate observa că metoda I şi metoda II diferă ca şi structură numai
prin prizma imaginilor pe care sunt aplicate (metoda I se aplică pe imaginea obţinută în urma
transformatei Wavelet a imaginii pe nivele de gri, iar metoda II pe cea obţinută în urma
transformatei Wavelet a transformatei FFT). Numărul de trăsături obţinute prin aplicarea acestor
două metode este acelaşi indiferent de imaginea pe care sunt aplicate (imagine pe nivele de gri,
cea rezultată în urma transformatei Wavelet sau cea rezultată în urma transformatei Wavelet a
transformatei FFT) şi indiferent de dimensiunea acesteia, doarece cele trei blocuri "primele 4
momente", histograme multiscalare şi caracteristicile Tamura contribuie cu un număr fix la
formarea vectorului de caracteristici (48, 24, respectiv 6).
Astfel, asupra transformatei Wavelet a imaginii, cât şi asupra transformatei Wavelet a
trasnformatei FFT, se vor aplica următoarele funcţii de compresie a numărului de coefienţi:
a) Histogramele multiscalare - funcţie care transformă imaginea de intrare în patru tipuri de
histograme, cu 3, 5, 7 şi 9 benzi, rezultând astfel 24 de valori. Aceste valori sunt normalizate cu
maximul lor.
b) "Primele 4 momente" - funcţie care returnează un număr de 48 de coeficienţi, prin parcurgerea
imaginii:
- pe diagonală (atât din strânga jos pâna în dreapta sus, cât şi din dreapta jos până în stânga sus)
cu un pas care depinde de valoarea rotujită a împărţirii dimensiunii pe vericală a imaginii la zece
(round(dim_verticala/10)). La fiecare pas se calculează valoarea mediei, deviaţiei standard,
oblicităţii şi planităţii pixelilor parcuşi. Coloanele matricei astfel obţinută (care are stocate pe
fiecare linie cele patru valori menţionate) sunt transformate în histograme cu 3 benzi, rezultând
un număr de 4x3=12 atribute pentru fiecare imagine.
- pe orizontală şi pe verticală, cu deosebirea că faţă de parcurgerea pe diagonală cea realizată pe
orizontală se va face cu un pas care depinde de dimensiunea verticală a imaginii, iar cea
verticală se va face cu un pas care depinde de dimensiunea orizontală a imaginii. În rest se
procedează la fel ca şi la parcurgerea pe diagonală.
Aşadar, pentru cele patru parcurgeri (două pe diagonală, una pe verticală şi una pe
orizontală) se obţin un număr de [4 parcurgeri]x[4 coloane]x[3 benzi ale histogramelor]=48
trăsături pentru orice imagine asupra căreia s-a aplicat această metodă de reducere a trăsăturilor.
c) Trăsăturile Tamura care se compun din directionalitatea imaginii, contrastul, granularitatea şi
o histogramă a granulitaţii cu 3 benzi.
Până acum au fost trecute în revistă primele două metode de reducere a atributelor unei
imagini (metoda I şi metoda II), iar în continuare vom aborda celelate două metode - metoda III
şi metoda IV.
În cadrul metodei III de reducere a atributelor, blocurile: "primele 4 momente",
histograme multiscalare, caracteristicile Tamura, au aceeaşi funcţionare ca şi în cazul blocurilor
similare din metoda I şi metoda II, cu deosebirea că acestea acţionează asupra imaginii originale
(imagine pe nivele de gri). Acestor blocuri i se adaugă şi transformata Radon.
Pentru a realiza transformata Radon s-a utilizat funcţia deja implementată în Matlab:

R = radon(I, theta) care returnează transformata Radon R a intensitaţii imaginii I pentru un unghi de theta grade [23].

Au fost calculate transformatele Radon pentru patru valori ale lui theta - 0଴, 45଴, 90଴ şi 135଴.
Fiecare coloană a lui R va conţine transfromata Radon pentru fiecare unghi din theta. Apoi
coloanele matricei R sunt transformate în patru histograme a câte trei benzi fiecare. Astfel,
transformata Radon participă cu un număr total de 4x3=12 trăsături la formarea vectorului de
caracteristici.
Metoda IV de extragere a trăsăturilor constă în descompunerea polinomială Zernike a
imaginilor pe nivele de gri. Rezultatele obţinute în urma aplicării polinoamelor Zernike asupra
imaginii sunt valori complexe, şi de aceea descriptorii imaginii vor fi modulul acestor valori

16
(valoarea absolută a numerelor complexe obţinute).
La aceste metode s-a ajuns pornind de la cele descrise în [9] pentru formarea vectorului
de trăsături din cadrul clasificatorului WND-CHARM.
3.2.1 Metoda de extragere a caracteristicilor din WND-CHARM
Metoda propusă pentru formarea vectorului de trăsături al clasificatorului WND-CHARM
este ilustrată în următoarea figură:

Figura 3.3 Schema de formare a vectorului de trăsături din cadrul WND-CHARM [9]

După cum se poate observa în figura 3.3 pentru formarea vectorului de trăsături s-au
utilizat diferite transformate ale imaginilor (transformata Wavelet, transformata Chebyshev şi
transformata FFT), precum şi combinaţii ale acestor transformate (transformata Wavelet a
transformatei FFT şi transformata Chebyshev a transformatei FFT). Apoi din rezultatele obţinute
în urma acestor transformate, au fost extrase diferite trăsături, care sunt grupate în funcţie de
tipul lor (caracteristici de mare contrast, de descompunere polinomială, de statistică şi textură)
în patru grupe astfel:

Figura 3.4 Grupele de caracteristici pentru formarea vectorului de trăsături din WND-CHARM
[9]
În figura 3.4 este descrisă componenţa fiecărei grupe de caracteristici. Astfel, grupa A
cuprinde următoarele caracteristici de contrast înalt(de formă):
- statisticile muchiilor care sunt calculate pe gradientul imaginii originale şi cuprind mai
multe caracteristici cum ar fi media, varianţa, o histogramă cu opt benzi a magnitudinii şi
direcţiei pixelilor, numărul total de pixeli muchie normalizat în raport cu dimensiunea imaginii,
omogenitatea direcţiei şi o histogramă cu patru benzi care ilustrează diferenţa direcţiei muchiilor.
Astfel, prin extragerea acestor statistici din imagine se obţine un număr de 28 de trăsături.
- coeficienţii Gabor se obţin prin utilizarea wavelet-urilor Gabor[9], obţinându-se un
număr de 7 coeficienţi pentru fiecare imagine.

17
 - statisticile obiectelor sunt calculate pe imaginea binarizată prin intermediul pragului
Otsu [9] şi cuprind următoarele caracteristici: numărul lui Euler (diferenţa dintre numărul de
obiecte şi numărul de găuri din imagine), centroizii imaginii, minimul, maximul, media, varianţa
şi o histogramă cu zece benzi calculată pentru pixelii obiectelor şi distanţa de la centroizii
obiectelor la centrul imaginii. În total statisticile obiectelor cuprind 34 de caracteristici.
După cum se poate observa în figura 3.3 caracteristicile din grupa A sunt extrase numai din
imaginea originală, contribuind astfel cu un număr de 28+7+34=69 caracteristici la formarea
vectorului de trăsături.
Grupa B reprezentată de caracteristicile de descompunere polinomială (de geometrie), are
în componenţă următoarele trăsături:
- statisticile Chebyshev- Fourier sunt extrase prin aplicarea transformatei Chebyshev-
Fourier asupra unei imagini, obţinându-se un număr de 32 de trăsături.
- statisticile Chebyshev sunt obţinute prin transformarea coeficienţilor rezultaţi în urma
transformării Chebyshev a imaginii într-o histogramă cu 32 de benzi.
- polinoamele Zernike - prin descompunerea polinomială Zernike se obţin 72 de
coeficienţi complecşi, dar ca descriptori ai imaginii se folosesc valorile absolute ale acestora.
După cum se poate observa în figura 3.3 caracteristicile din grupa B sunt extrase din imaginea
originală şi imaginea rezultată în urma transformatei FFT a imaginii originale, contribuind astfel
cu un număr de 2x(32+32+72)=272 caracteristici la formarea vectorului de trăsături.
Grupa C, după cum se poate observa în figura 3.4 este compusă din următoarele
caracteristici de statistică a pixelilor şi de textură:
- primele 4 momente sunt reprezentate de media, deviaţia standard, oblicitatea şi
planitatea imaginii. Fiecare din cele patru caracteristici enumerate sunt formate dintr-o
histogramă cu 12 benzi, rezultând 48 de caracteristici.
- trăsăturile Haralick sunt calculate cu ajutorul matricelor concurente ale imaginilor.
Aceste trăsături cuprind un număr de 28 valori.
- histograme multiscalare sunt obţinute prin transformarea imaginii în patru tipuri de
histograme, cu 3, 5, 7 şi 9 benzi, rezultând astfel 24 de valori.
- caracteristicile Tamura se compun din direcţionalitatea imaginii, contrastul,
granularitatea şi o histogramă a granulitaţii cu 3 benzi. Aceste trăsături contribuie cu un număr
de 6 caracteristici la formarea vectorului de trăsături.
După cum se poate observa în figura 3.3 caracteristicile din grupa C sunt extrase din
transformata Wavelet a imaginii originale şi transformata Wavelet a transformatei FFT a
imaginii originale, contribuind astfel cu un număr de 2x(48+28+24+6)=212 caracteristici la
formarea vectorului de trăsături.
Grupa D este formată din statisticile pixelilor şi caracteristicile de textură ce fac parte din
grupa C la care se adaugă şi caracteristicile Radon a imaginii originale. Prin aplicarea
transformatei Radon asupra unei imagini se obţine un număr total de 4x3=12 trăsături.
După cum se poate observa în figura 3.3 caracteristicile din grupa D sunt extrase din imaginea
originală, transformata FFT a imaginii originale, transformata Chebyshev (a imaginii originale şi
a transformatei FFT a imaginii originale), contribuind astfel cu un număr de 4x(48+28+24
+6+12)=472 caracteristici la formarea vectorului de trăsături.
Pentru mai multe detalii despre modul în care au fost calculate caracteristicile din grupele
A, B, C şi D a se consulta [9].

3.2.2 Metoda de extragere a caracteristicilor în lucrarea de faţă

În această lucrare formarea vectorului de caracteristici s-a realizat având ca referinţă
figura 3.3. Pentru obţinerea unor timpi de extragere a trăsăturilor şi de clasificare mai buni este
necesar a se utiliza un vector de trăsături cu o dimensiune cât mai mică. Astfel, pentru calculul
vectorului de caracteristici, în lucrarea de faţă se vor utiliza un număr mai redus de trăsături.
Pentru reducerea numărului de trăsături, dar şi din cauza numărului foarte mare de
posibilităţi de formare a vectorului de trăsături (disponibile în figura 3.3), în această lucrare s-a

18
procedat astfel:
- s-a plecat de la formarea vectorului de trăsături prin împărţirea figurii 3.3 în mai nouă
metode de extragere caracteristicilor (primele nouă linii ale tabelului 3.1) şi testarea fiecărei
metode în parte.
- s-au relizat combinaţii ale celor nouă metode de extragere (după cum se poate observa
în tabelul 3.1) până când s-a ajuns la o performanţă de clasificare satisfăcătoare.
- încă de la început s-a renunţat din grupa A la coeficienţii Gabor (datorită numărului mic
de trăsături şi timpului de obţinere mai ridicat faţă de celelalte caracteristici ale grupei), din
grupa B la statisticile Chebyshev-Fourier (deoarece utilizează pentru calcul o mare parte din
memorie şi timpul de obţinere este foarte mare), din grupa C la trăsăturile Haralick (datorită
timpului de obţinere foarte mare şi modului complicat de calcul).

Acurateţe KNN Acurateţe KNN

Nr. Weka Matlab
crt. Metoda de extragere a trăsăturilor [%] [%]
k k
1 3 5 1 3 5
1. imagine → transformata Wavelet → grupa C 70.6 68 70 70 62 68.3
2. imagine → transformata Chebyshev → grupa D 66.1 66.5 62.7 65.7 64.4 63.7
3. imagine → transformata FFT → transformata 68 67.5 75.5 66.3 65.6 74
Wavelt → grupa C
4. imagine → transformata FFT → transformata 64.8 65.4 65.3 63.2 61.3 63.2
Chebyshev → grupa D
5. imagine → transformata FFT → grupa B 68.9 67.2 65.8 68 67.3 65.8
6. imagine → transformata FFT → grupa D 59 53.3 60 56.9 51.9 58.5
7. imagine → grupa A 62.7 62.7 60.4 63 64.3 61.3
8. imagine → grupa B 81.5 80.7 83.5 80.6 81.9 82.8
9. imagine → grupa D 82.5 83.5 82.5 85 86.2 87
imagine → transformata Wavelet → grupa C +
10. imagine → grupa A 70 71 73 69.3 70.6 70
imagine → transformata Wavelet → grupa C +
11. imagine → grupa A + 70.6 73.7 72 69.3 71.2 70
imagine → transformata FFT → transformata
Wavelet→ grupa C
imagine → transformata Wavelet → grupa C +
12. imagine → grupa A + imagine → grupa B 70 71 73 69.3 70.6 70

imagine → transformata Wavelet → grupa C+

13. imagine → transformata FFT → grupa B 81 80.5 79.8 81.8 81.2 80.6

imagine → transformata Wavelet → grupa C +

14. statisticile Radon extrase din imaginea 86.8 86.8 86.2 86.2 87.5 87.5
originală
imagine → transformata Wavelet → grupa C +
15. statisticile Chebyshev extrase din imaginea 73.7 71.2 73 70.6 70.6 70.6
originală
imagine → transformata Wavelet → grupa C +
statisticile Chebyshev extrase din imaginea
16. originală + statisticile Radon extrase din 82.5 85 85 82.5 82.5 80
imaginea originală

19
 Acurateţe KNN Acurateţe KNN
Nr. Weka Matlab
crt. Metoda de extragere a trăsăturilor [%] [%]
k k
1 3 5 1 3 5
17. imagine → transformata Wavelet → grupa C + 85.6 85 82.5 87 88.7 88
imagine → grupa D
imagine → transformata Wavelet → grupa C +
18. imagine → grupa D + imagine → grupa B 87.5 87.8 85 90 86.9 87.5

imagine → transformata Wavelet → grupa C +

19. imagine → grupa D+ imagine → grupa B+ 87.9 87.5 85.6 91.3 86.3 86.3
imagine → transformata FFT → transformata
Wavelet → grupa C
Tabel 3.1 Metode de extragere a trăsăturilor analizate

În tabelul 3.1 se pot observa valorile acurateţii de clasificare obţinute atât în Matlab cât şi în
Weka, prin intermediul clasificatorului KNN, respectiv IBk pentru un număr de vecini k= 1,3 sau
5.
După cum se poate observa în tabelul 3.1, metoda de extracţie a trăsăturilor care oferă cea
mai mare acurateţe este descrisă în ultima secţiune a tabelului.
Nu s-a mai continuat testarea altor combinaţii de metode de extragere a trăsăturilor
deoarece s-a obţinut o acurateţe de clasificare satisfăcătoare şi pentru că timpul de extragere a
trăsăturilor pentru toate imaginile din baza de date să nu mai crească (pentru că este şi aşa unul
foarte ridicat- 3 ore şi 12 minute).
Asfel, s-a ajuns la următoarea schemă de formare a vectorului de caracteristici, care este
utilizată mai departe în această lucrare:

Figura 3.5 Schema de formare a vectorului de trăsături

20
Figura 3.5 reprezintă schema de formare a vectorului de caracteristici pentru care s-a obţinut o
acurateţe de clasificare satisfăcătoare prin intermediul clasificatorului IBk din Weka şi
clasificatorului KNN implemantat în Matlab.
Metodele de extragere a trăsăturilor ilustrate în figura 3.5 sunt descrise mai amănunţit în
în figura 3.2 şi în secţiunea 3.2 a lucrării de faţă.
Astfel, după cum se observă în figura 3.5 vectorul de caracteristici al fiecărei imagini va
fi format din 318 trăsături. Pentru întreaga bază de imagini vectorul de trăsături va fi format din
318 trăsături x 800 de imagini.

3.2.3 Evaluarea trăsăturilor în Weka

Weka este un sistem foarte puternic cu ajutorul căruia se poate realiza numai clasificarea
obiectelor (nu şi extragerea caracteristicilor).
Utilitarul poate fi descărcat gratuit de pe site-ul: http://www.cs.waikato.ac.nz/ml/weka/. Acesta
a fost utilizat pentru a aplica o metodă de învăţare aupra vectorului de caracteristici şi pentru a
analiza rezultatele obţinute. Înainte de aplicarea oricărui algoritm de clasificare asupra datelor,
acestea trebuie convertite în fisiere ARFF ("Attribute-Relation File Format").
Structura fişierului ARFF trebuie să respecte următoarea formă:

Figura 3.6 Structura fişierului ARFF la modul general

Figura 3.6 ilustreză modul de formare al unui fişier ARFF, în vederea antrenării şi testării unui
clasificator ales din Weka cu trăsăturile extrase din imaginile cuprinse în baza de date.
Astfel, pentru vectorul de caracteristici format pe baza schemei din figura 3.5, structura
fişierului ARFF va fi următoarea:

Figura 3.7 Structura fisierului ARFF utilizat în acestă lucrare

21
 În figura 3.7 este prezentată schema de formare a fişierului ARFF adaptată la această
lucrare.
Aşadar, fiecare atribut trebuie descris în header-ul
header fişierului ARFF, fişierul conţinind
informaţii atât despre tipul fiecărui atribut, precum şi despre clasa din care face parte respectivul
obiect.
Clasa fiecărui obiect trebuie să fie cunoscută, pentru ca la testare să se poată compara
clasa prezisă de clasificator
asificator cu clasa reală a obiectului respectiv. Dupa antrenarea (învăţarea)
datelor se obţine o matrice de confuzie ("confusion matrix") având dimensiunea [număr_clase x
număr_clase], în cazul nostru 4x4, care arată numărul instanţelor atribuite fiecărei clase de
obiecte. Dacă toate instanţele au fost clasificate corect atunci doar elementele diagonalei
principale ale matricei de confuzie sunt diferite de zero. zero Dacă spre exemplu vom avea
următoarele matrice de confuzie descrise în figura 3.8:

Figura 3.8 Matricele

Matrice de confuzie pentru învăţare, respectiv testare

Notaţiile realizate în figura 3.8 au următoarele seminificaţii: M - clasa maşini, P - clasa

pietoni, A - clasa animale şi G -clasa garbage.
În figura 3.8 se poate observa că la învăţare toate obiectele au fost atribuite corect claselor
din care fac parte (figura
figura 3.8 a).
a
În etapa de testare (figura 3.8 b):
- toate obiectele din clasa maşini (prima linie a matricei din figura 3.8 b)) au fost clasificate corect
- din clasa pietoni (a doua linie a matricei din figura 3.8 b)) 36 de imagini au fost clasificate
corect, 3 au fost clasificate ca făcând parte din clasa animale şi 1 din clasa garbage
- din clasa animale 34 de imagini au fost clasificate
clasif corect (a treia linie a matrice
matricei din figura 3.8
b), 1 a fost clasificată
asificată ca fiind din clasa maşini,
maş 2 au fost atribuite clasei pietoni şi 3 clasei
garbage
- din clasa garbage (ultima linie a matricei din figura 3.8 b) 28 de imagini au fost clasificate
clase maşini şi 9 clasei animale.
corect, 3 au fost clasificate ca aparţinând clasei
Figura 3.8 prezintă matricele le de confuzie pentru
pentru învâţare, respectiv testare obţinute în Weka cu
clasificatorul IBk.. Numărul de vecini al clasificatorului IBk este egal cu unuunu, iar pentru formarea
vectorului de trăsături s-aa utilizat schema prezentată în figura 3.5.
Pentru învăţare şi testare vectorul de caracteristici al tuturor imaginilor din baza de date a
fost împărţit manual în 80% instanţe pentru învăţare şi 20% pentru testare, astfel încât să avem
un număr de 160 de imagini din fiecare clasă pentru antrenare
an (din
din întreaga baza de date un total
de 640 de imagini)) şi 20% din fiecare clasă pentru testare (din întreaga bază de date un total de
160 de imagini).
Programul Weka pune la dispoziţie un număr mare de algoritmi de învăţare şi testare.
Deoarece în lucrarea de faţă s-a s a pus accentul pe extragerea trăsăturilor şi nu pe analiza
performanţelor diferiţilor clasificatori, pentru a evalua calitatea trăsăturilor extrase din imagini ss-
a utilizat clasificatorul IBk.

3.3.4 Evaluarea trăsăturilor în Matlab

Apelarea din Matlab a utilitarului Weka este una dificilă. Din acest motiv, dar şi datorită
necesităţii folosirii unui clasificator în interfaţa grafică a lucrării de faţă ss-a ales dezvoltarea în
Datorită simplităţii şi uşurinţei de implementare
Matlab a unui algoritm de clasificare. Datorită implementare, pentru

22
evaluarea trăsăturilor în Matlab s-a ales utilizarea clasificatorului KNN.
În această lucrare au fost utilizate pentru compararea performanţelor de clasificare două
versiuni ale clasificatorului KNN:
 KNNC (KNN Classify) care este un clasificator implementat cu ajutorul funcţiei deja
existente în Matlab:
Class = knnclassify(Sample, Training, Group, k, distance) [23].
Funcţia knnclassyfy returnează vectorul Class, care conţine rezultatul clasificării
imaginilor din vectorul Sample în funcţie de imaginile cu ajutorul cărora se realizează învăţarea
clasificatorului KNN.
Această funcţie are ca şi parametrii:
- vectorul Sample care conţine imaginile de testare şi a cărui linii vor fi clasificate în cele patru
clase.
- vectorul Training care conţine imaginile de antrenare, fiind folosit la clasificarea obiectelor din
vectorul Sample. Numărul de coloane a celor doi vectori Sample şi Training trebuie să fie egal.
- vectorul Group conţine clasele imaginilor din setul de antrenare
- k este numărul de vecini utilizat în clasificare
- distance este metrica utilizată în clasificare
 KNNR (KNN Rule) care este implementat de Roger Jang şi poate fi descărcat gratuit de
pe site-ul: http://mirlab.org/jang/matlab/toolbox/dcpr/.
Cu acest clasificator se obţine exact aceeaşi acurateţe de clasificare, dar un timp de
clasificare mult mai bun. Acest lucru se datorează utilizării MEX-files, care au rolul de a reduce
timpul necesar în mod normal Matlab-ului să realizeze operaţiile dorite.
În interfaţa grafică va fi utilizat numai clasificatorul KNNR datorită performanţelor de
clasificare superioare (în ceea ce priveşte timpul de clasificare).
Astfel utilitarul Weka este folosit pe lângă stabilirea metodei de extragere a trăsăturilor şi
la verificarea implementării în Matlab a celor două clasificatoare KNN.

3.3 Determinarea parametriilor transformatei Wavelet

În această lucrare s-a utilizat transformata Wavelet discretă pentru semnale
bidimensionale. În Matlab această transformată are următoarea sintaxă:
[cA,cH,cV,cD] = dwt2(X,'wname') [23]
Prin această transformată se calculează matricea coeficienţilor aproximaţi cA şi matricele
coeficienţilor detaliaţi cH, cV şi cD (pe orizontală, verticală şi respectiv pe diagonală) prin
descompunerea wavelet a matricei de intrare X (care poate fi reprezentată de o imagine).
Transformata Wavelet are ca parametru numele familiei wavelet utilizat în descompu-
nere. Tot un parametru al transformatei Wavelet poate fi considerat şi nivelul de descompunere
wavelet.
Descompunerea wavelet se poate realiza pe mai multe nivele astfel:
- mai întâi se realizează transformata Wavelet a imaginii prin metoda descrisă mai sus (utilizată
pentru obţinerea primului nivel de descompunere wavelet)
- pentru obţinerea celui de-al doilea nivel al descompunerii se va aplica transformata Wavelet pe
una din matricele coeficienţilor (cA, cH, cV sau cD) sau pe o combinaţie a acestor matrice.
- se continuă cu aplicarea transformatei Wavelet pe noile matrice de coeficienţi până când se
atinge nivelul de descompunere dorit.
Pentru determinarea parametriilor transformatei Wavelet s-a realizat următorul
experiment:
- s-a ales un nivel de descompunere egal cu 3, 4, 5 sau 6 (nivelele 1 şi 2 nu oferă o
compresie suficientă a atributelor imaginii). Aşadar sunt patru valori ale nivelului de
descompunere.
- pentru funcţiile mamă ale descompunerii wavelet s-au folosit funcţiile deja
implementate in Matlab, precum: Daubechies, Coiflet, Symlet, biortogonale şi inverse
biortogonale (reverse biortogonal) .

23
 Numele familiei de funcţii wavelet Daubechies se scrie dbN, unde N este ordinul, iar db
este "prenumele" funcţiei wavelet. Funcţiile Coiflet (coifN) reprezintă o altă familie de funcţii
discrete wavelet, descoperite de Ingrid Daubechies. Numele familiei de funcţii wavelet Symlet se
scrie symN, unde le fel ca şi la Daubechies, N este ordinul, iar sym este "prenumele" funcţiei
wavelet. Functiile wavelet biortogonale se scriu biorNr.Nd, iar funcţiile inverse biortogonale la
fel ca şi cele biortogonale se scriu rbioNr.Nd.
Din varietatea de familii de wavelet-uri în acest experiment s-au utilizat următoarele
funcţii: db1db15, coif1coif5, sym1sym15, bior 1.1bior6.8, rbio1.1rbio6.8 (în total un
număr de 64 de valori)
- s-a utilizat numai metoda I de extragere a trăsăturilor (descrisă în figura 3.2) având ca
scop a reducerea timpul de extragere pentru imaginile din baza de date.
Astfel, prin utilizarea metodei I au fost obţinuţi vectorii de trăsături ai bazei de imagini
pentru valorile parametriilor transformatei Wavelet stabilite mai sus. S-au obţinut un număr de
4x64=256 vectori de caracteristici, care au fost salvaţi în fişiere text. La sfârşitul fiecărei linii a
fişierului s-a introdus clasa reală a imaginii (pentru a se putea calcula acurateţea de clasificare)
- s-a realizat permutarea liniilor tuturor fişierelor, pentru a nu permite clasificatorului să
înveţe inclusiv ordinea de preluare a imagnilor (deoarece clasificatorul prelua pe rând cele 4
clase, iar prin permutare imaginile sunt preluate aleator)
- pentru învăţare şi testare datele au fost împărţite asfel încât să se obţină 80% din
imaginile fiecărei clase pentru învăţare şi 20% pentru testare (câte 160 imagini din fiecare clasă
pentru învăţare şi 40 imagini din fiecare clasă pentru testare).
- s-a realizat clasificarea imaginilor din cele 256 de fişiere prin intermediul
clasificatorului KNN. S-a optat pentru obţinerea unei acurateţi de clasificare cât mai bună, în
defavoarea unor timpi calcul a transformatei Wavelet mai ridicaţi (cu cât nivelul de descom-
punere este mai mare cu atât timpul necesar realizării transformatei Wavelet este mai ridicat, dar
scade timpul de clasificare).
În urma acestui experiment s-a observat că acurateţea maximă se obţine pentru familia de
wavelet-uri bior1.3 şi nivelul de descompunere wavelet egal cu 3.
Coeficienţii cA, cH, cV şi cD de nivlel 3 şi familie bior1.3 ai unei imagini arată astfel:

Figura 3.9 Transformata Wavelet a unei imagini

În figura 3.9 este prezentat rezultatul aplicării transformatei Wavelet de familie bior1.3 şi
nivel de descompunere wavelet 3 asupra unei imagini oarecare din baza de date. În urma aplicării
transformatei wavelet de nivel 3 şi familie bior1.3 s-a realizat reducerea numarului de atribute al
imaginii prezentate în figură de la [148x93] (valori ce reprezintă dimensiunea imaginii originale)
pâna la [16x22]. După cum se poate observa în figura 3.2 din rezultatul transformatei Wavelet al
imaginii sunt extrase caracteristicile: "primele 4 momente", histograme multiscalare şi
caracteristicile Tamura, numărul de trăsături reducându-se de la [16x22=352] la 78 (48 pentru
"primele 4 momente", 24 pentru histogramele multiscalare şi 6 pentru caracteristicile Tamura).

3.4 Modul de împărţire a datelor pentru învăţare şi testare

După cum se poate observa în figura 3.10, orice clasificator trebuie să aibe un set de date
pentru antrenare şi altul pentru testare. Iesirea unui astfel de clasificator este un vector care

24
conţine numărul asociat claselor imaginilor din setul de testare (clasa_testare care este un vector
coloană).

Figura 3.10 Schema bloc a clasificării KNN

În funcţie de tipul clasificatorului setul de date de antrenare, respectiv de testare trebuie

să aibe o anumită structură. Astfel pentru cele două variante ale clasificatorului KNN (KNNC şi
KNNR) setul de antrenare şi cel de testare va fi compus astfel:
- setul de antrenare este format din doi vectori - vector_trăsături_antrenare, care conţine pe
fiecare linie trăsăturile imaginilor destinate antrenării şi clasa_antrenare, care este un vector
coloană ce conţine pe fiecare linie clasa corespondentă imaginii sotocate pe aceeaşi linei în
vectorul de antrenare.
- setul de testare este format dintr-un singur vector care are acelaşi număr de coloane ca şi
vector_trăsături_antrenare, conţinând pe fiecare linie trăsăturile unei imagini de test.
Numărul de linii al acestor vectori depind de procentul de imagini din baza de date
destinate antrenării şi testării. Cum s-a ales un procent de 80% din imaginile fiecărei clase pentru
antrenare şi 20% pentru testare, aceşti vectori vor avea următoarea dimensiune:
- vector_trăsături_antrenare: 80% x 800 imagini = 640 imagini, iar pentru fiecare imagine s-au
extras 318 trăsături. Astfel dimensiunea datelor de învăţare este [640 linii x 318 coloane].
- vector_trăsături_testare: 20% x 800 imagini = 160 imagini, iar pentru fiecare imagine s-au
extras 318 trăsături. Astfel dimensiunea datelor de testare este [160 linii x 318 coloane].
- clasa_antrenare după cum a mai fost precizat este un vector coloană cu acelaşi număr de linii
ca şi vector_trăsături_antrenare. Aşadar vom avea o dimensiune de [640 linii x 1 coloană].
- clasa_testare este tot un vector coloană care conţine acelaşi număr de linii ca şi
vector_trăsături_testare rezultând astfel dimensiunea [160 linii x 1 coloană].
Testarea clasificatorului KNN s-a realizat pentru un număr de vecini k=1,3 sau 5. După
cum se poate observa k ia doar valori impare, din cauză că avem patru clase şi s-a dorit evitarea
cazurilor în care clasificatorul poate atribuii imaginea la doua clase diferite în acelaşi timp (dacă
acesta gaseşte aceeaşi distanţă între vecinii săi care fac parte din două clase diferite).
Acurateţea clasificării a fost calculată ca raportul dintre instanţele corect clasificate şi
număr total de instanţe clasificate. Determinarea instanţelor corect clasificate s-a realizat prin
compararea claselor prezise de clasificator cu clasele reale (predefinite) ale imaginilor clasificate.
Din acest motiv este necesar stocarea claselor reale ale imaginilor de test.

3.5 Îmbunătăţirea performanţelor

S-a încercat îmbunătăţirea performanţelor prin două metode:
- reducerea numărului de trăsături extrase din fiecare imagine
- transformarea aplicaţiei într-un executabil

3.5.1 Reducerea numărului de trăsături extrase din fiecare imagine

După cum se poate observa în figura 3.5 formarea vectorului de trăsături se realizează
prin aplicarea asupra imaginilor din baza de date a combinaţiei celor patru metode de extragere:
metoda I, metoda II, metoda III şi metoda IV.
În tabelul 3.1 nu au fost analizate rezultatele tuturor combinaţiilor posibile de formare a
vectorului de trăsături. Astfel, s-a încercat reducerea numărului de trăsături extrase din fiecare

25
imagine prin analiza tuturor modalităţilor posibile de formare a vectorului de trăsături pornind de
la cele patru metode: metoda I, metoda II, metoda III şi metoda IV.
Deoarece avem un număr de patru metode de extragere, numărul de modalităţi posibile de
obţinere a vectorului de trăsături este dat de:

‫ܥ‬ସଵ + ‫ܥ‬ସଶ + ‫ܥ‬ସଷ + ‫ܥ‬ସସ = 4 + 6 + 4 + 1 = 15 modalităţi

Cele cincisprezece modalităţi de formare a vectorului de trăsături sunt obţinute prin aplicarea
asupra imaginilor a următoarelor metode şi combinaţii de metode de extragere:
1. metoda I
2. metoda II
3. metoda III
4. metoda IV
5. metoda I +metoda II
6. metoda I + metoda III
7. metoda I + metoda IV
8. metoda II + metoda III
9. metoda II + metoda IV
10. metoda III + metoda IV
11. metoda I + metoda II + metoda III
12. metoda I + metoda II + metoda IV
13. metoda I + metoda III + metoda IV
14. metoda II + metoda III +IV
15. metoda I +metoda II + metoda III + metoda IV
Au fost formaţi astfel cincisprezece vectori de caracteristici ai bazei de imagini,
dimensiunea lor variind în funcţie de modalitatea de extragere a trăsăturilor (a se vedea tabelul
4.1 pentru mai multe detalii).
Pentru clasificarea celor cincisprezece vectori de caracteristici s-a procedat după cum
urmează:
- s-a realizat o aplicaţie de extragere a trăsăturilor din imaginile bazei de date pentru toate cele
cincisprezece modalităţi de formare a vectorului de caracteristici. Vectorii astfel formaţi au fost
salvaţi în fişiere text.
- s-a realizat permutarea liniilor tuturor fişierelor, pentru a nu permite clasificatorului să înveţe
inclusiv ordinea de preluare a imagnilor
- pentru învăţare şi testare datele au fost împărţite asfel încât să se obţină 80% din imaginile
fiecărei clase pentru învăţare şi 20% pentru testare (câte 160 imagini din fiecare clasă pentru
învăţare şi 40 imagini din fiecare clasă pentru testare)
- s-a realizat clasificarea imaginilor din cei cincisprezece vectori de caracteristici prin
intermediul clasificatorului KNN
- rezultatele de clasificare a celor cincisprezece vectori au fost comparate pe baza acurateţii de
clasificare.
Acurateţea dată de fiecare combinaţie de metode, a fost comparată cu rezultatele obţinute
pentru combinaţia metoda I+metoda II+metoda III +metoda IV (cea cu care s-a obţinut cea mai
bună acurateţe de clasificare). Astfel s-a observat că modalităţile compuse din metoda III +
metoda IV, metoda I + metoda III + metoda IV, metoda II + metoda III + metoda IV, se apropie
foarte mult de acurateţea obţinută cu metoda I+metoda II+metoda III +metoda IV, fără a o
depăşii (90.63 % faţa de 91.25%).
În cazul celor trei modalităţi (metoda III + metoda IV, metoda I + metoda III + metoda
IV, metoda II + metoda III + metoda IV) se obţine un timp de clasificare mai bun (0.09 secunde
faţă de 0.11) decât în cazul metodei cu care s-a obţinut cea mai bună acurateţe (metoda I+metoda
II+metoda III +metoda IV). Acest lucru se datorează numărului mai mic de trăsături pe imagine
(pentru mai multe detalii consultaţi tabelul 4.1)

26
 Totuşi, am optat pentru obţinerea unei acurateţi de clasificare cât mai bună în detrimentul
unui timp de clasificare mai scăzut.

3.5.2 Transformarea aplicaţiei într-un executabil

S-a încercat îmbunătăţirea performanţelor în ceea ce priveşte timpii de clasificare a
tuturor celor cincisprezece combinaţii posibile de creare a vectorului de caracteristici, prin
transformarea aplicaţie realizate într-un fişier executabil. În acest scop am utilizat toolbox-ul
deploytool din Matlab, care urmăreşte următoarea schemă bloc pentru realizarea unui astfel de
fişier:

Figura 3.11 Schma bloc urmată de toolbox-ul deploytool[23]

În figura 3.11 este prezentat modul foarte simplu de realizare a unui fişier executabil.
S-a ales acest mod de realizare a executabilului datorită simplităţii precum şi datorită
dorinţei de a obţine timpi de clasificare mai buni. Astfel cu ajutorul acestui toolbox şi urmărind
paşii de mai sus s-a realizat transformarea aplicaţiei realizate în Matlab într-o aplicaţie
"standalone" (de sine statătoare, care nu necesită instalarea Matlab-ului pentru rulare) pentru
sistemul de operare Windows.

3.6 Interfaţa grafică a aplicaţiei

Pentru a realiza o prezentare a acestei lucrări s-a relizat o interfaţă grafică GUI (Graphical
User Interface) cu ajutorul toolbox-ului GUIDE (Graphical User Interface Design Environment)
din Matlab. Această aplicaţie a fost transformată într-una executabilă cu ajutorul deploytool.
Interfaţă grafică arată astfel:

Figura 3.12 Interfaţa grafică a lucrării

27
 În figura 3.12 este prezentată aplicaţia GUI realizată prin intermediul toolbox-urilor
Matlab (GUIDE + deploytool).
Interfată grafică este formată din trei părti:
- partea de extragere a trăsăturilor
- partea de clasificare a imaginilor
- partea de testare a clasificatorului KNN cu alte imagini decât cele din baza de date

3.6.1 Extragerea trăsăturilor

Interfaţa grafică permite utilizatorului să aleagă clasele de imagini utilizate în etapa de

extragere a trăsăturilor, precum şi metodele de extracţie a trăsăturilor (poate să aleagă orice
combinaţie a celor patru metode descrise în figura 3.2). După apăsarea butonului "Creare vector
trăsături" se va realiza extragerea trăsăturilor prin metoda aleasă din imaginile claselor selectate.
Timpul de extragere al trăsăturilor tuturor imaginilor din baza de date va fi vizibil utilizatorului
odată cu terminarea procesului de extragere în căsuţa numerotată cu "2", iar informaţiile legate
de numărul de caracteristici al vectorului de trăsături astfel format vor fi vizibile în căsuţa
numerotată cu "1".

3.6.2 Clasificarea imaginilor

Pentru clasificarea imaginilor s-a ales clasificatorul KNNR. Interfaţa permite setarea
numărului de vecini pentru care se face clasificarea (căsuţa "3") şi procentului din numărul total
de imagini destinat procesului de învăţare (căsuţa 4). Procentul de imagini pentru care se face
testarea se calculează automat prin scăderea din 100% a procentului de imagini de învăţare.
Acesta este afişat odată cu setarea procentului de învăţare în căsuţa "5".
Prin apăsarea butonului "Antrenare şi testare KNN" se realizează clasificarea imaginilor
din setul de testare în funcţie de parametrii setaţi. Informaţiile legate de acurateţea clasificării şi
timpul de clasificare vor fi afişate în căsuţele "6",respectiv "7".

3.6.3 Testarea clasificatorului KNN şi cu alte imagini decât cele din baza de date

Interfaţa grafică permite testarea clasificatorului KNN şi cu alte imagini decât cele din
baza de date, în funcţie de vectorul de trăsături extras "on-line" sau în funcţie de vectorul de
trăsături implicit obţinut în cadrul celei mai bune metode de extragere a caracteristicilor (metoda
I+metoda II+metoda III+metoda IV).
Pentru a se realiza testarea, utilizatorul trebuie să aleagă o nouă imagine prin apăsarea
butonului "Preia imagine" şi să selecteze vectorul de trăsături utilizat. Trăsăturile imaginii
preluate vor fi extrase prin aceleaşi metode prin care s-a format şi vectorul de trăsături ales (cel
format on-line sau cel implicit). Informaţiile legate de timpul de extragere a trăsăturilor, timpul
de clasificare şi clasa imaginii noi vor fi afişate în căsuţele "8", "9", respectiv "10".

4. Rezultate experimentale

Toate experimentele din acestă lucrare au fost relizate pe un calculator desktop având
următoarea configuraţie:
- placă de bază: ASUS M3N78-VM
- procesor: AMD Athlon(tm) 64 3000+, având o frecvenţă de 1.8Ghz
- RAM: 2 Gb DDR II
- placaă video: Nvidia GeForce 8200
- HDD: 250 Gb, 7200 rpm
- sistem de operare: Windows XP Service Pack 3

28
 4.1 Rezultate experimentale Weka

Pentru a avea convingerea că trăsăturile din vectorul de caracteristici sunt destul de

diferenţiate de la o clasă la alta, s-a folosit clasificatorul IBk (echivalentul KNN-ului) din Weka.
Astfel s-a relizat testarea clasificatorului IBk cu datele de învăţare, obţinându-se următoarea
matrice de confuzie:

Figura 4.1 Matrice de confuzie Weka (numărul de vecini=1)

Figura 4.1 prezintă matricea de confuzie obţinută în Weka prin testarea clasificatorului
IBk cu datele de învăţare, pentru vectorul de trăsături construit după figura 3.5. În figura de mai
sus se observă că în afară de diagonala principală celelalte elemente sunt zero, ceea ce înseamnă
că nici o imagine nu a fost atribuită altei clase decât celei din care face parte.
Ei bine, situaţia pentru cazul în care numărul de vecini este mai mare ca unu (respectiv k=3 sau
5) se schimbă, făcând ca acurateţea clasificării să nu mai fie de 100%. Astfel în acest caz s-au
obţinut următoarele matrice de confuzie:

(a) (b)

Figura 4.2 Matricele de confuzie pentru k=3 (a),

respectiv k=5 (b) obţinute în Weka

Figura 4.2 prezintă matricele de confuzie obţinute în Weka, prin testarea clasificatorului
IBk cu datele de învăţare (pentru vectorul de trăsături construit după figura 3.5), ilustrând
rezultatele diferite obţinute pentru k=3 (figura 4.2 a), respectiv k=5 (figura 4.2 b) faţă de primul
caz (figura 4.1) când k=1.
După cum se poate observa în matricele de confuzie de mai sus celelate elemente în afara
diagonalei principale nu sunt nule ca şi în figura 4.1, având şi imagini care nu sunt atribuite
corect. Astfel, când k=3 pentru clasa maşini (notată cu M) au fost atribuite corect 199 de imagini
din 200, una fiind atribuită incorect clasei animale (notată cu A), pentru clasa pietoni (notată cu
P) - 193 corecte,7 incorecte, ş.a.m.d.
Acurateţea de clasificare în acest caz scade la 93.75% (adică 750 imagini clasificate
corect din totalul de 800), pentru k=3 la 93.75 şi la 92.25% pentru k=5 (adică 738 de imagini
clasificate corect din totalul de 800). Acest lucru relevă că pentru k=3 şi k=5 nu s-a realizat o
diferenţiere suficientă între cele patru clase (existănd asemănări între acestea) şi după cum o să
putem observa în cele ce urmează performaţele de clasificare cele mai bune se vor obţine pentru
k=1. S-a ales pentru numărul de vecini valori impare (1,3, respectiv 5) din cauză că sunt patru

29
clase şi s-a dorit evitarea cazurilor în care clasificatorul poate atribuii imaginea la doua clase
diferite în acelaşi timp.
De asemenea, Weka a fost utilizat şi pentru verificarea implementării clasificatoarelor
KNN (KNNC şi KNNR) în Matlab.
Astfel, în etapa de testare, în Weka se obţin următoarele matrice de confizie:

(a) (b) (c)

Figura 4.3 Matricele de confuzie pentru setul de testare (k=1,3 şi 5) obţinute în Weka
În figura 4.3 putem observa modul în care au fost atribuite imaginile din setul de testare
(format din 20% din imaginile fiecărei clase, adică 40 de imagini din fiecare clasă) în urma
evaluării imaginilor cu ajutorul clasificatorului IBk. Astfel, pentru k=1 s-a obţinut o acurateţe de
clasificare de 86.25% (adică 138 de imagini clasificate corect din totalul de 160), pentru k=3 -
86.25%, iar pentru k=5 - 86.875% (adică 139 de imagini clasificate corect din totalul de 160).
În Matlab, în etapa de testare pentru ambele clasificatoare KNN (KNNC şi KNNR) s-au
obţinut următoarele matrice de confuzie:

(a) (b) (c)

Figura 4.4 Matricele de confuzie pentru setul de testare obţinute în Matlab

În figura 4.4 este prezentat rezultatul atribuirii imaginilor fiecărei clase, pentru setul de
testare, clasificarea fiind realizată în Matlab prin intermediul celor două clasificatoare KNN
studiate. Aceste clasificatoare returnează acelaşi rezultat al clasificării în ceea ce priveşte
acurateţea, diferenţa majoră dintre ele fiind constituită de timpii de clasificare.
În comparaţie cu clasificatorul IBk din Weka, pentru cele din Matlab s-a obţinut o
acurateţe de clasificare puţin mai mare, respectiv pentru k=1 (figura 4.4 a) s-a obţinut o acurateţe
de 91.25% (adică 146 imagini clasificate corect din totalul de 160), pentru k=3 (figura 4.4 b)
86.25% (adică 137 de imagini clasificate corect din totalul de 160) şi pentru k=5 (figura 4.4 c)
86.25%.

4.2 Rezultate experimentale din Matlab şi din aplicaţia executabilă

Aplicaţia executabilă se referă la experimentul (transformat în fişier executabil) realizat

pentru obţinerea celor cincisprezece combinaţii posibile de formare a vectorului de trăsături în
secţiunea:
3.5.1 Reducerea numărului de trăsături extrase din fiecare imagine, a lucrării de faţă.
Diferenţa în ceea ce priveşte timpii de clasificare dintre cele două clasificatoare (KNNC

30
şi KNNR) în funcţie de numărul de trăsături extrase (de combinaţia de metode utilizată pentru
construirea vectorului de trăsături) poate fi observată atât în figura 4.5, cât şi în tabelul 4.1.

Figura 4.5 Graficul timpului de clasificare în funcţie de numărul de trăsături

În figura 4.5 sunt prezentate sunt prezentate următoarele grafice:
- graficul timpului de clasificare KNNR (cel cu albastru) al celor cincisprezece vectori de
caracteristici (pentru mai multe detalii vezi secţiunea 3.5.1 a acestei lucrări) în funcţie de
numărul de de trăsături extrase din imagini pentru fiecare combinaţie de metode (vezi tabelul
4.1)
- graficul timpului de clasificare KNNC (cel cu roşu) al celor cincisprezece vectori de
caracteristici în funcţie de numărul de de trăsături extrase din imagini pentru fiecare combinaţie
de metode (vezi tabelul 4.1).
După cum observăm în figura 4.5 timpul de clasificare KNNR este mult mai bun, având valori
mai mici decât timpul de clasificare KNNC.Timpul de clasificare KNNC este divizat cu zece
pentru a se putea observa mai bine diferenţele între cele două grafice în fiecare punct.
Comparând valorile timpilor de clasificare KNNR obţinuţi în Matlab şi în aplicaţia
executabilă din figura 4.6 putem observa că performanţele obţinute în Matlab nu diferă foarte
mult de cele obţinute prin intermediul aplicaţiei executabile.

Figura 4.6 Graficul timpului de clasificare în funcţie de numărul de trăsături

31
 Figura 4.6 prezintă variaţia timpilor de clasificare ai KNNR-ului obţinuţi în cadrul
aplicaţiei Matlab (cu albastru), respectiv în cadrul aplicaţiei executabile (cu roşu) de obţinere a
performanţelor de clasificare pentru cele cincisprezece moduri de formare a vectorului de
trăsături, fiind relizată în Matlab.

Figura 4.7 Graficul timpului de extragere coeficienţi în funcţie de numărul de trăsături

Figura 4.7 prezintă graficul timpului de extragere a coeficienţilor (obţinut în Matlab- cu

albastru şi în aplicaţia executabilă- cu roşu) în funcţie de numărul de trăsături.
După cum se poate observa în figura 4.7, diferenţele dintre timpul de extragere a
caracteristicilor pentru toate imaginile din baza de date în cazul aplicaţiei Matlab, respectiv
aplicaţiei standalone, sunt atât de mici încât reprezentările grafice a acestora în funcţie de
numărul de trăsături extrase pentru fiecare imagine sunt suprapuse. Astfel, transformarea unei
aplicaţii Matlab într-un executabil nu oferă performanţe cu mult mai bune în ceea ce priveşte
timpii de execuţie, dar este utilă pentru rularea aplicaţiei Matlab pe calculatoarele care nu au
instalat programul Matlab.
În tabelul 4.1 sunt prezentate rezultatele experimentale obţinute în Matlab, prin
clasificarea tuturor celor cincisprezece posibilităţi de creare a vectorului de trăsături. După cum
putem observa, tabelul informează asupra numărului de trăsături din vectorul de caracteristici
construit conform metodei specificate, timpul de extragere al coeficienţilor tuturor imaginilor din
baza de date, numărul de vecini k al clasificatorului KNNR pentru care s-a obţinut acurateţea de
clasificare cea mai mare, acurateţea de clasificare pentru fiecare clasă de imagini din baza de
date, acurateţea medie a celor patru clase de imagini, timpul necesar clasificatoarelor KNNR şi
KNNC să clasifice setul de testare constituit din atributele a 20% din imaginile fiecărei clase
(40 de imagini din fiecare clasă).
În tabelul 4.2 sunt prezentate aceeaşi termeni de performanţă a clasificării şi extragere a
trăsăturilor, cu excepţia timpului de clasificare KNNC, obţinuţi în urma transformării aplicaţiei
de obţinere a celor cincisprezece vectori de atribute şi de clasificare a acestora într-o aplicaţie
executabilă independentă de Matlab. Prin această transformare s-a încercat îmbunătăţirea
performanţelor de extragere şi de clasificare prin îmbunătăţirea timpilor de extragere a
trăsăturilor, respectiv timpilor de clasificare a setului de testare pentru fiecare din cei
cincisprezece vectori de atribute.

32
 Tabel 4.1 Rezultate obţinute în Matlab
Combinaţia de Număr Timp extragere k Acurateţe [%] Acurateţea Timp Timp
Nr. Metode trăsături coeficienţi medie clasificare clasificare
1 3 5 Masini Pietoni Animale Garbage
crt [%] KNNR KNNC
[s] [s]
1 I 78 1 min, 11 sec x 95 90 50 68 75.63 0.05 0.30

2 II 78 1 min, 41 sec x 88 88 60 47 70.63 0.07 0.21

3 III 90 17 min x 97 85 75 80 84.38 0.05 0.45

4 IV 72 2 h, 51 min x 100 97 45 85 81.88 0.04 0.20

5 I II 156 2 min, 51 sec x 97 95 70 72 83.75 0.06 0.62

6 I III 168 18 min x 97 85 75 85 85.63 0.07 0.65

7 I IV 150 2 h, 52 min x 100 97 50 85 83.13 0.06 0.68

8 II III 168 19 min x 97 85 75 82 85 0.07 0.80

9 II IV 150 2 h, 53 min x 100 97 55 90 85.63 0.06 0.73

10 III IV 162 3 h, 9 min x 100 95 78 90 90.63 0.09 0.79

11 I II III 246 20 min x 97 85 75 85 85.63 0.09 1.26

12 I II IV 228 2 h, 54 min x 100 97 60 90 86.88 0.08 0.97

13 I III IV 240 3 h, 10 min x 100 95 78 90 90.63 0.09 1.21

14 II III IV 240 3 h, 10 min x 100 95 78 90 90.63 0.09 1.27

15 I II III IV 318 3 h, 12 min x 100 95 80 90 91.25 0.10 1.30

33
 Tabel 4.2 Rezultate obţinute prin transformarea aplicaţiei într-un executabil

Combinaţia Număr Timp k Acurateţe [%] Acurateţea Timp

Nr. de Metode trăsături extragere medie clasificare
crt
coeficienţi 1 3 5 Masini Pietoni Animale Garbage [%] KNNR[s]
1 I 78 1 min, 7 x 95 90 50 68 75.63 0.04
sec
2 II 78 1 min, 34 x 88 88 60 47 70.63 0.04
sec
3 III 90 16 min x 97 85 75 80 84.38 0.04

4 IV 72 2 h, 51 sec x 100 97 45 85 81.88 0.04

5 I II 156 2 min, 41 x 97 95 70 72 83.75 0.06

sec
6 I III 168 18 min x 97 85 75 85 85.63 0.06

7 I IV 150 2 h, 52 min x 100 97 50 85 83.13 0.06

8 II III 168 18 min x 97 85 75 82 85 0.06

9 II IV 150 2 h, 52 min x 100 97 55 90 85.63 0.06

10 III IV 162 3 h,8 min x 100 95 78 90 90.63 0.08

11 I II III 246 19 min x 97 85 75 85 85.63 0.09

12 I II IV 228 2 h, 54 min x 100 97 60 90 86.88 0.08

13 I III IV 240 3 h, 9 min x 100 95 78 90 90.63 0.08

14 II III IV 240 3h, 9 min x 100 95 78 90 90.63 0.10

15 I II III IV 318 3 h, 11 min x 100 95 80 90 91.25 0.10

34
 În figura de mai jos (figura 4.8) se poate observa rata de clasificare a celor patru clase
(masini- în galben, pietoni- în roşu, animale- în verde şi garbage- în albastru), precum şi
acurateţea medie (cu linie neagră întreruptă) în funcţie de numărul de trăsături al vectorului de
caracteristici.

Figura 4.8 Graficul acurateţii în funcţie de numărul de trăsături

Figura 4.8 prezintă acurateţea de clasificare a celor patru clase şi acurateţea medie în funcţie de
numărul de trăsături al vectorului de caracteristici, fiind realizată în Matlab.
După cum se poate observa în acestă figură clasa cu cea mai bună rată de recunoaştere
este clasa maşini, urmată de clasa pietoni, fapt ce poate fi explicat prin existenţa unui număr
suficient de imagini, care să permită clasificatorului o învăţare eficientă. În cazul celorlalte două
clase, animale şi garbage, acurateţea de clasificare este mai scăzută datorită varietăţii de fundale
ale imaginilor.

5. Concluzii

Pe durata realizării acestei lucrări au fost studiate diferite metode deja existente de
formare a vectorului de trăsături în vederea clasificării imaginilor.
Din multitudinea de metode studiate (vezi figura 3.3), s-a ajuns la schema de formare a
vectorului de caracteristici prezentată în figura 3.5. În funcţie de acurateţea de clasificare, a fost
aleasă combinaţia de metode ce mai bună de extragere a trăsăturilor din imaginile bazei de date.
Din punct de vedere aplicativ a fost dezvoltată o interfaţă grafică, care permite
utilizatorului să selecteze diferite variante de formare a vectorului de trăsături, precum şi
posibilitatea testării clasificatorului KNN cu alte imagini decât cele din baza de date. Vectorul de
trăsături poate avea, în funcţie de metodele alese, o dimensiune minimă de 72 caracteristici şi
maximă de 318 caracteristici.
Principalul avantaj al aplicaţiei realizate, în comparaţie cu metoda de extragere
caracteristici propusă în WND-CHARM (figura 3.3) este numărul mult mai redus de trăsături pe
imagine, ceea ce are o influenţă foarte mare asupra timpului de extragere al coeficienţilor tuturor
imaginilor din baza de date, precum şi asupra timpului de clasificare.
Astfel, timpul necesar extragerii trăsăturilor (pentru care se obţine acurateţea cea mai

35
bună) este de 3 ore şi 11 minute, în comparaţie cu cele 48 de ore necesare extragerii
caracteristicilor cu metoda propusă în WND-CHARM. De asemenea, s-a obţinut o acurateţe de
clasificare mult mai bună, decât dacă se realiza extragerea caracteristicilor pe baza metodologiei
descrisă în figura 3.3 (91.25% faţă de 68%).
În ceea ce priveşte baza de imagini, s-a ajuns la concluzia că aceasta trebuie să aibe un
număr mai mare de imagini cel puţin pentru clasele animale şi garbage, pentru ca rezultatele
clasificării să fie îmbunătăţite.
Acurateţea de clasificare nu creşte liniar odată cu extragerea mai multor trăsături din
imaginile bazei de date (vezi figura 4.8).
Prin extragerea mai multor caracteristici din fiecare imagine se măreşte timpul de
extragere al trăsăturilor, precum şi timpul de clasificare. De aceea pentru a avea o clasificare
într-un timp cât mai redus trebuie să se facă un compromis între dimensiunea vectorului de
trăsături şi timpul de clasificare.
Prin transformarea aplicaţiei Matlab într-una executabilă nu se pot obţine timpi de
execuţie mai buni, dar aceasta este folositoare la rularea aplicaţiei realizate în Matlab pe
calculatoarele care nu au instalat acest program.
În urma rezultatelor obţinute, Weka s-a dovedit un program foarte util în stabilirea
metodelor eficiente de formare a vectorului de trăsături, precum şi în verificarea implementărilor
Matlab a clasificatoarelor KNN (KNNC şi KNNR).
Problemele cele mai importante, întâmpinate în realizarea acestei lucrări au fost:
- construirea unei baze de date care să conţină un număr suficient de imagini pe clasă
Acurateţea de clasificare a fiecărei clase după cum se poate observa şi în figura 4.8 nu
este aceeaşi pentru toate clasele şi datorită faptului că nu a fost realizată o bază de date special
concepută pentru această lucrare, imaginile care formează cele patru clase făcând parte din baze
de imagini diferite.
- dimensiunea diferită a imaginilor din baza de date
Această problemă a fost rezolvată prin folosirea unor metode de extragere a trăsăturilor
care să aibe ca rezultat acelaşi număr de caracteristici indiferent de dimensiunea imaginii. Astfel,
dimensiunea vectorului de trăsături nu variază de la o imagine la alta, fiind aceeaşi pentru toate
imaginile. Această condiţie este necesară la clasificarea imaginilor. Extragerea unui număr
constant de trăsături din fiecare imagine (indiferent de dimensiunea lor) se putea realiza şi prin
redimensionarea tuturor imaginilor din baza de date la aceeaşi dimensiune, dar rezultatele
obţinute nu sunt la fel de bune.
Aplicaţia realizată poate fi utilizată cu succes la dezvoltarea unor sisteme de recunoaştere
de obstacole, întălnite de o maşină pe şosea, sisteme automate de supraveghere a parcărilor sau
sisteme de utilaje automate în vederea efectuării unor lucrări agricole.
Prin schimbarea bazei de imagini cu una constituită din imagini medicale, aplicaţia poate fi
utilizată în domeniul medical pentru detecţia anomaliilor sau procesarea imaginilor biologice.

36
6. Bibliografie

[1] Smith, J.R., Chang, S.F., 1996. Local color and texture extraction and spatial query. Proc.
IEEE International Conference on Image Processing, Lausanne, Switzerland, September 1996.

[2]Shen, L., Bai, L., 2006. MutualBoost learning for selecting Gabor features for face
recognition, Pattern Recognition Letters, 27, 1758–1767.

[3] Jing, X.Y., Zhang, D., 2004. A Face and Palmprint Recognition Approach Based on
Discriminant DCT Feature Extraction. IEEE Transactions on Systems, Man, and Cybernetics,
34, 2405–2414.

[4] Pentland, A., Choudhury, T., 2000. Face recognition for smart environments. Computer, 33,
50–55.

[5] Boland, M.V., Murphy, R.F., 2001. A Neural Network Classifier Capable of Recognizing the
Patterns of all Major Subcellular Structures in Fluorescence Microscope Images of HeLa Cells.
Bioinformatics, 17, 1213–1223.

[6] Awate, S.P., Tasdizen T., Foster N., Whitaker R.T., 2006. Adaptive Markov modeling for
mutualinformation-based, unsupervised MRI braintissue classification. Medical Image Analysis,
10,726–739.

[7] Cocosco, A., Zijdenbos, P., Evans, A.C., 2004. A fully automatic and robust brain MRI tissue
classification method. Medical Image Analysis, 7, 513–527.

[8] Ranzato, M., Taylor, P.E., House, J.M., Flagan, R.C., LeCun, Y., Perona, P., 2007.
Automatic recognition of biological particles in microscopic images. Pattern Recognition Letters,
28, 31–39.

[9] http://www.phy.mtu.edu/~lshamir/publications/image_classifier.pdf

[10]http://www.upm.ro/facultati_departamente/stiinte_litere/conferinte/situl_integrare_european
a/Lucrari2/Ioan_Ispas.pdf

[11] http://www.dtic.upf.edu/~xserra/cursos/TDP/referencies/Park-DWT.pdf

[12] http://www.mathworks.com

[13] ac.upg-ploiesti.ro/cursuri/is/lab/IS_LUC%203.doc

[14] http://www.wisdom.weizmann.ac.il/~naor/COURSE/fft-lecture.pdf

[15] http://en.wikipedia.org/wiki/Fast_Fourier_transform#Cooley.E2.80.93Tukey_algorithm

[16] http://eivind.imm.dtu.dk/staff/ptoft/Radon/Radon.html

[17] http://imag.pub.ro/ro/cursuri/archive/radon.pdf

[18] http://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB:Radon_transform.
png

37
[19]http://www.cs.auckland.ac.nz/compsci708s1c/lectures/Glect-
html/topic4c708FSC.htm#tamura

[20] http://en.wikipedia.org/wiki/Zernike_polynomials

[21] http://www.astronomy.ohio-state.edu/~martini/Astro890/Astro890L6.pdf

[22] http://inf.ucv.ro/~gorunescu/courses/curs/clustering.pdf

[23] Malab R2009b Help

[24] http://people.revoledu.com/kardi/tutorial/KNN/index.html

[25]http://www.autonlab.org/autonweb/14665/version/2/part/5/data/moore-
tutorial.pdf?branch=main&language=en

[26] http://www.mathworks.com/support/tech-notes/1600/1605.html#intro

38
 7. Anexe

7.1 Anexa 1
Codul Matlab al funcţiei de transformare Wavelet

function [coef_img]=compresie_wavelet(imagine,nivel,tip_transformare)
%imagine= imaginea asupra careia se va aplica transformata wavelet dwt2
%nivel= nivelul de compresie al imaginilor
%tp_transformare= familia de wavelet-uri folosita
for i=1:nivel
% extragem coeficientii aproximati, de pe orizontala, verticala si
% diagonala
[cA1,cH1,cV1,cD1] = dwt2(imagine,tip_transformare);
imagine=cA1;
end;
coef_img=cA1;
return;

7.2 Anexa 2
Codul Matlab pentru obţinerea fişierului cu vectorul de trăsături

clc
close all
clear all
%fis- fisierul in care va fi salvat vectorul de trasaturi
fis=fopen('fisier_caracteristici.txt','w' );
for i=1:4
% Lista contine numele imaginilor din baza de date
lista=strcat('Lista',num2str(i),'.txt');
% functia care realizeaza extragerea trasaturilor pentru fiecare
% clasa pe rand
citesteImaginiLista(lista,fis);
end
fclose all;

7.3 Anexa 3
Codul Matlab al funcţiei de extragere trăsături

function citesteImaginiLista(fisLst,fis)
%fisLst - fisierul txt care contine denumirea imaginilor
%fis - fisierul in care se va scrie vectorul de trasaturi

% preiau nr de imagini in functie de numarul de linii al fisierului Lista

numberOfLines = GiveNbOfLines(fisLst);
fid_imagesLst=fopen(fisLst);
% punem in variabila dirImagini folderul din care sa citeasca imaginile
nume_lista = {'Lista1.txt','Lista2.txt','Lista3.txt','Lista4.txt'};
T=strcmp(fisLst, nume_lista);
currentfolder=pwd;
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\persons\'),...
strcat(currentfolder,'\animals\'),...

39
 strcat(currentfolder,'\garbage\')};
[T,clasa]= sort(T,'descend');
clasa=clasa(1);
dirImagini=dirImagini{clasa};

for i = 1:numberOfLines-1

% preiau numele fiecarei imagini din fisierul fid_imagesLst

imgName = numeImagine(fid_imagesLst);
% citesc imaginea si o transform din color in gray
[imagine] = imread(strcat(dirImagini,imgName),'png');
imagine=rgb2gray(imagine);
imagine = im2double(imagine);

%metoda I de extractie
%aplicare transformata wavelet
caracteristici_wavelet1=compresie_wavelet(imagine,3,'bior1.3');
%aplicare first4moments, MultiScaleHistograms, TamuraTextures asupra
%transformatei wavelet a imaginii
first4moments = CombFirst4Moments(caracteristici_wavelet1);
multiscalehist = MultiScaleHistograms(caracteristici_wavelet1);
TamuraFeatures = TamuraTextures(caracteristici_wavelet1);
vect_caracteristici=[first4moments,multiscalehist,TamuraFeatures];

%metoda II de extractie
% aplicare FFT
fftTrans=FourierTransform(imagine);
caracteristici_wavelet_fft=compresie_wavelet(fftTrans(:,:,1),3,'bior1.3');
%aplicare first4moments, MultiScaleHistograms, TamuraTextures asupra
%transformatei wavelet a transformatei fft a imaginii
first4moments = CombFirst4Moments(caracteristici_wavelet_fft);
multiscalehist = MultiScaleHistograms(caracteristici_wavelet_fft);
TamuraFeatures = TamuraTextures(caracteristici_wavelet_fft);

vect_caracteristici=[vect_caracteristici,first4moments,multiscalehist,...
TamuraFeatures];

%metoda III de extractie

%aplicare first4moments, MultiScaleHistograms, TamuraTextures si
% RadonTransform asupra imaginii originale
first4moments = CombFirst4Moments(imagine);
multiscalehist= MultiScaleHistograms(imagine);
TamuraFeatures = TamuraTextures(imagine);
radonTransStat = RadonTransformStatistics(imagine);

vect_caracteristici=[vect_caracteristici,first4moments,multiscalehist,...
TamuraFeatures,radonTransStat];

% metoda IV de extractie
%aplicare polinoamele lui zernike asupra imaginii originale
zvalues = ZernikePolynomials(imagine);

40
vect_caracteristici=[vect_caracteristici,zvalues];
%% salvam rezultatul in fisier
lungime=size(vect_caracteristici,2);
for j=1:lungime
fprintf(fis,'%.3f', vect_caracteristici(j));
fprintf(fis,'%c',',');
end;
fprintf(fis,'%d%c\n',clasa,',');

end

fclose(fid_imagesLst);

7.4 Anexa 4
Codul Matlab pentru obţinerea fişierului cu liniile vectorului de caracteristici permutate

close all
clear all
clc

calea=strcat(pwd,'\fisiere\');
% fisierul in care este salvat vectorul de trasaturi
fisierulmeu=strcat(calea,'fisier_caracteristici.txt');
% functia care realizeaza permutarea datelor precum si impartirea lor in
% 80% si 20% pentru invatare si testare
prelucrareFisierIN(fisierulmeu);
fclose all;

Codul Matlab pentru funcţia prelucrarefisierIN

function prelucrareFisierIN(fisierulmeu)
% fac permutari de linii, pt ca sa nu-i dau posibilitatea
% clasificatorului sa invete inclusiv ordinea obiectelor
%preiau datele din fisier si le transform in 80% pentru invatare si 20 %
%pentru testare
xy=preiaDatelePtPrel(fisierulmeu);
lungime=size(xy);
clasa1=xy(1:lungime(1)/4,:);
clasa2=xy(lungime(1)/4+1:2*lungime(1)/4,:);
clasa3=xy(2*lungime(1)/4+1:3*lungime(1)/4,:);
clasa4=xy(3*lungime(1)/4+1:lungime(1),:);
size1=size(clasa1);
size2=size(clasa2);
size3=size(clasa3);
size4=size(clasa4);
clasa1_invatare=clasa1(1:0.8*size1(1),:);
clasa1_test=clasa1(0.8*size1(1)+1:end,:);
clasa2_invatare=clasa2(1:0.8*size2(1),:);
clasa2_test=clasa2(0.8*size2(1)+1:end,:);
clasa3_invatare=clasa3(1:0.8*size3(1),:);

41
clasa3_test=clasa3(0.8*size3(1)+1:end,:);
clasa4_invatare=clasa4(1:0.8*size4(1),:);
clasa4_test=clasa4(0.8*size4(1)+1:end,:);

date_invatare=[clasa1_invatare;clasa2_invatare;clasa3_invatare;clasa4_invatare];
date_testare=[clasa1_test;clasa2_test;clasa3_test;clasa4_test];
%permutare linii
date_invatareperm = permutareLinii(date_invatare);
date_testareperm = permutareLinii(date_testare);
date=[date_invatareperm;date_testareperm];

%salvez datele in alt fisier -fis_testare_random1.txt

calea=strcat(pwd,'\fisiere random\');
fid_scriere=fopen(strcat(calea,'fisier_caracteristici_random.txt'),'w');
%matricea cu parametrii imaginilor cu liniile permutate

%scrierea matricei in noul fisier-fisier_caracteristici_random1.txt

dim1=size(date);
for k1=1:dim1(1)
fprintf(fid_scriere,'%s',date{k1,1});
fprintf(fid_scriere,'\n');
end
fclose(fid_scriere);
Codul Matlab pentru functia preiaDatelePtPrel

function [xa] = preiaDatelePtPrel(fis)

% functie cu care citesc datele dintr-un fisier .txt, linie cu linie
% ca stringuri

numberOfLines = GiveNbOfLines(fis);
fid_imagesLst_app=fopen(fis);
clear xa;
clear ya;
clear nrul;
nr_instante=((numberOfLines-1));

for i = 1:nr_instante

%preluam fiecare linie ca un string si o salvam intr-o matrice de

%stringuri
tline = fgetl(fid_imagesLst_app);
xa{i,1}=tline;
end

fclose(fid_imagesLst_app);

Codul Matlab pentru funcţia permutareLinii

function [rez] = permutareLinii(matrice)

% face permutarea liniilor matricei de la intrare; structura lui "matrice"
% ar trebui sa fie : pe linia se gaseste info despre obiectul 1 si tot asa,
% iar pe coloane sunt caracteristicile si clasa obiectelor

42
dim=size(matrice);
rez=matrice(randperm(dim(1)),:);

7.5 Anexa 5
Codul Matlab pentru clasificarea KNN

close all
clear all
clc
%fisierul in care salvam rezultatele clasificarii
calea=strcat(pwd,'/rezultate/');
fis1=fopen(strcat(calea,'rezultateknn.txt'),'w');

calea= strcat(pwd,'/fisiere/');

%fisierul din care preluam vectorul de trasaturi

fisierulmeu=strcat(calea,'fisier_caracteristici.txt');
[x y]=preiaDatelePtPrel(fisierulmeu);
[dim1,dim2]=size(x);
%din parametrii tuturor imaginilor 80% le retinem pentru antrenare si 20%
%pentru testare
number = round(8*dim1/10);

%xapp- matricea de antrenare

xapp=x(1:number,1:dim2-1);

%xtest- matricea de test

xtest=x(number+1:dim1,1:dim2-1);

%yapp- vectorul care contine clasele imaginilor de antrenare

yapp=y(1:number);
%ytest- vectorul care contine clasele imaginilor de testare
ytest=y(number+1:dim1);

timp=0;
accuracy=0;
% facem antrenarea si testarea KNN pentru k=1,3 si 5, unde k=numarul de
% vecini
for k=1:2:5
tic
%clasificatorul KNNC
%computedOutput=knnclassify(xtest,xapp,yapp,k);
% clasificatorul KNNR
DS.input=xapp';
DS.output=yapp';
TS.input=xtest';
knnrParam.k=k;
[computedOutput, combinedComputedOutput, nearestIndex, knnrMat] =...
knnr(DS, TS, knnrParam);
%timpul de clasificare
timp=toc;
accuracy=computeAccuracy(ytest,computedOutput')*100;

43
perf=0.5*timp+0.5*(1-accuracy/100);
%scrierea rezultatelor obtinute in fisier
fprintf(fis1,'%d %.2f %.2f %.2f\n',k,timp,accuracy,perf);
% matricea de confuzie
confusion=confusionmatrix(ytest',computedOutput);
% calculul acuratetii de clasificare pentru fiecare clasa
accuracy_cars=confusion(1,1)/40;
accuracy_persons=confusion(2,2)/40;
accuracy_animals=confusion(3,3)/40;
accuracy_garbage=confusion(4,4)/40;
%scrierea rezultatelor obtinute in fisier
fprintf(fis1,'%.2f %.2f %.2f
%.2f\n',accuracy_cars,accuracy_persons,accuracy_animals,accuracy_garbage);
end;

fclose all;

7.6 Anexa 6
Codul Matlab al aplicaţiei GUI

function varargout = licentaexe(varargin)

% LICENTAEXE M-file for licentaexe.fig
% LICENTAEXE, by itself, creates a new LICENTAEXE or raises the existing
% singleton*.
%
% H = LICENTAEXE returns the handle to a new LICENTAEXE or the handle to
% the existing singleton*.
%
% LICENTAEXE('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in LICENTAEXE.M with the given input arguments.
%
% LICENTAEXE('Property','Value',...) creates a new LICENTAEXE or raises the
% existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before licentaexe_OpeningFcn gets called. An
% unrecognized property name or invalid value makes property application
% stop. All inputs are passed to licentaexe_OpeningFcn via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help licentaexe

% Last Modified by GUIDE v2.5 03-Jun-2010 12:06:20

% Begin initialization code - DO NOT EDIT

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @licentaexe_OpeningFcn, ...
'gui_OutputFcn', @licentaexe_OutputFcn, ...

44
 'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT

% --- Executes just before licentaexe is made visible.

function licentaexe_OpeningFcn(hObject, eventdata, handles, varargin)

% This function has no output args, see OutputFcn.

% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to licentaexe (see VARARGIN)
% afisarea imaginii NO_IMAGE de fiecare data cand aplicatia este rulata
[imagine_init,map]=imread('no_image.jpg');
imshow(imagine_init,map,'parent',handles.axes1);
% Choose default command line output for licentaexe
handles.output = hObject;
% Update handles structure
guidata(hObject, handles);

% UIWAIT makes licentaexe wait for user response (see UIRESUME)

% uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.
function varargout = licentaexe_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure

varargout{1} = handles.output;

% --- Executes on button press in radiobutton3 - masini

function radiobutton3_Callback(hObject, eventdata, handles)
% hObject handle to radiobutton3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton3

45
% --- Executes on button press in radiobutton4 - pietoni
function radiobutton4_Callback(hObject, eventdata, handles)
% hObject handle to radiobutton4 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton4

% --- Executes on button press in radiobutton5 - animale

function radiobutton5_Callback(hObject, eventdata, handles)
% hObject handle to radiobutton5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton5

% --- Executes on button press in radiobutton6 - garbage

function radiobutton6_Callback(hObject, eventdata, handles)
% hObject handle to radiobutton6 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton6

function edit1_Callback(hObject, eventdata, handles)

%preluarea procentului de invatare si testare
procent_invatare=str2double(get(handles.edit1,'String'));
if (isnan(procent_invatare)||(procent_invatare<=0)||procent_invatare>100)
errordlg('Introduceti un numar mai mic sau egal cu 100',...
'Error');

else procent_testare=100-procent_invatare;
set(handles.edit2,'String',num2str(procent_testare));
end
% hObject handle to edit1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit1 as text

% str2double(get(hObject,'String')) returns contents of edit1 as a double

% --- Executes during object creation, after setting all properties.

function edit1_CreateFcn(hObject, eventdata, handles)

46
% hObject handle to edit1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function edit2_Callback(hObject, eventdata, handles)

% hObject handle to edit2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit2 as text

% str2double(get(hObject,'String')) returns contents of edit2 as a double

% --- Executes during object creation, after setting all properties.

function edit2_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function edit3_Callback(hObject, eventdata, handles)

% hObject handle to edit3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit3 as text

% str2double(get(hObject,'String')) returns contents of edit3 as a double

% --- Executes during object creation, after setting all properties.

function edit3_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.

47
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% --- Executes on button press in pushbutton1.

function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
close all

function edit4_Callback(hObject, eventdata, handles)

% preluarea numarului de vecini pentru care sa se clasifice
numar_vecini=str2double(get(handles.edit4,'String'));
if (isnan(numar_vecini)||(numar_vecini<=0))
errordlg('Introduceti un numar intreg de preferabil impar',...
'Error');
end;

% hObject handle to edit4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit4 as text

% str2double(get(hObject,'String')) returns contents of edit4 as a double

% --- Executes during object creation, after setting all properties.

function edit4_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit4 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% --- Executes on button press in radiobutton8 - metoda I

function radiobutton8_Callback(hObject, eventdata, handles)
dim_vect=str2double(get(handles.edit8,'String'));
handles.dim_vect=dim_vect;
% vedem daca metoda I va fi folosita
metoda1=get(handles.radiobutton8,'Value');
%calculam si afisam numarul de trasaturi care va compune vectorul de
%caracteristici
if (metoda1==0)

48
 dim_vect=handles.dim_vect;
dim_vect=dim_vect-78;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
else
dim_vect=handles.dim_vect;
dim_vect=dim_vect+78;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
end
% hObject handle to radiobutton8 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton8

% --- Executes on button press in radiobutton9 - metoda II

function radiobutton9_Callback(hObject, eventdata, handles)
% vedem daca metoda II va fi folosita
dim_vect=str2double(get(handles.edit8,'String'));
handles.dim_vect=dim_vect;

metoda2=get(handles.radiobutton9,'Value');
%calculam si afisam numarul de trasaturi care va compune vectorul de
%caracteristici
if (metoda2==0)
dim_vect=handles.dim_vect;
dim_vect=dim_vect-78;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
else
dim_vect=handles.dim_vect;
dim_vect=dim_vect+78;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
end
% hObject handle to radiobutton9 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton9

% --- Executes on button press in radiobutton10 - metoda III

function radiobutton10_Callback(hObject, eventdata, handles)
% vedem daca metoda II va fi folosita
dim_vect=str2double(get(handles.edit8,'String'));
handles.dim_vect=dim_vect;

metoda3=get(handles.radiobutton10,'Value');
%calculam si afisam numarul de trasaturi care va compune vectorul de

49
%caracteristici
if (metoda3==0)
dim_vect=handles.dim_vect;
dim_vect=dim_vect-90;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
else
dim_vect=handles.dim_vect;
dim_vect=dim_vect+90;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
end

% hObject handle to radiobutton10 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton10

% --- Executes on button press in radiobutton11 - metoda IV

function radiobutton11_Callback(hObject, eventdata, handles)
% vedem daca metoda II va fi folosita
dim_vect=str2double(get(handles.edit8,'String'));
handles.dim_vect=dim_vect;

metoda4=get(handles.radiobutton11,'Value');
%calculam si afisam numarul de trasaturi care va compune vectorul de
%caracteristici
if (metoda4==0)
dim_vect=handles.dim_vect;
dim_vect=dim_vect-72;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
else
dim_vect=handles.dim_vect;
dim_vect=dim_vect+72;
handles.dim_vect=dim_vect;
set(handles.edit8,'String',num2str(dim_vect));
end

% hObject handle to radiobutton11 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton11

% --- Executes on button press in pushbutton2 - antrenare si testare KNN

function pushbutton2_Callback(hObject, eventdata, handles)
% toate butoanele disable
disableButtons(handles);

50
% preluarea datelor din fisierul cu vectorul de trasaturi obtinut online
fisier_carac=strcat(pwd,'\fisier_caracteristici.txt');
fid_scriere=fopen(strcat(pwd,'\fisier_caracteristici_random.txt'),'w');
xy = preiaDatelePtrandomizare(fisier_carac);
lungime=size(xy);
% preia valoarea pentru procentul de invatare
procent_invatare=str2double(get(handles.edit1,'String'))/100;
% impartirea fiecarei clase in 80% pentru invatare si 20% pentru testare
% in functie de numarul de clase
if (lungime(1)==400)
clasa1=xy(1:lungime(1)/2,:);
clasa2=xy(lungime(1)/2+1:2*lungime(1)/2,:);
size1=size(clasa1);
size2=size(clasa2);

clasa1_invatare=clasa1(1:round(procent_invatare*size1(1)),:);
clasa1_test=clasa1(round(procent_invatare*size1(1))+1:end,:);
clasa2_invatare=clasa2(1:round(procent_invatare*size2(1)),:);
clasa2_test=clasa2(round(procent_invatare*size2(1))+1:end,:);

date_invatare=[clasa1_invatare;clasa2_invatare];
date_testare=[clasa1_test;clasa2_test];
date_invatareperm = permutareLinii(date_invatare);
date_testareperm = permutareLinii(date_testare);
date=[date_invatareperm;date_testareperm];

elseif (lungime(1)==600)
clasa1=xy(1:lungime(1)/3,:);
clasa2=xy(lungime(1)/3+1:2*lungime(1)/3,:);
clasa3=xy(2*lungime(1)/3+1:3*lungime(1)/3,:);

size1=size(clasa1);
size2=size(clasa2);
size3=size(clasa3);

clasa1_invatare=clasa1(1:round(procent_invatare*size1(1)),:);
clasa1_test=clasa1(round(procent_invatare*size1(1))+1:end,:);
clasa2_invatare=clasa2(1:round(procent_invatare*size2(1)),:);
clasa2_test=clasa2(round(procent_invatare*size2(1))+1:end,:);
clasa3_invatare=clasa3(1:round(procent_invatare*size3(1)),:);
clasa3_test=clasa3(round(procent_invatare*size3(1))+1:end,:);

date_invatare=[clasa1_invatare;clasa2_invatare;clasa3_invatare];
date_testare=[clasa1_test;clasa2_test;clasa3_test];
date_invatareperm = permutareLinii(date_invatare);
date_testareperm = permutareLinii(date_testare);
date=[date_invatareperm;date_testareperm];

51
elseif (lungime(1)==800)
clasa1=xy(1:lungime(1)/4,:);
clasa2=xy(lungime(1)/4+1:2*lungime(1)/4,:);
clasa3=xy(2*lungime(1)/4+1:3*lungime(1)/4,:);
clasa4=xy(3*lungime(1)/4+1:lungime(1),:);

size1=size(clasa1);
size2=size(clasa2);
size3=size(clasa3);
size4=size(clasa4);
clasa1_invatare=clasa1(1:round(procent_invatare*size1(1)),:);
clasa1_test=clasa1(round(procent_invatare*size1(1))+1:end,:);
clasa2_invatare=clasa2(1:round(procent_invatare*size2(1)),:);
clasa2_test=clasa2(round(procent_invatare*size2(1))+1:end,:);
clasa3_invatare=clasa3(1:round(procent_invatare*size3(1)),:);
clasa3_test=clasa3(round(procent_invatare*size3(1))+1:end,:);
clasa4_invatare=clasa4(1:round(procent_invatare*size4(1)),:);
clasa4_test=clasa4(round(procent_invatare*size4(1))+1:end,:);

date_invatare=[clasa1_invatare;clasa2_invatare;clasa3_invatare;clasa4_invatare];
date_testare=[clasa1_test;clasa2_test;clasa3_test;clasa4_test];
date_invatareperm = permutareLinii(date_invatare);
date_testareperm = permutareLinii(date_testare);
date=[date_invatareperm;date_testareperm];

end;
% scrierea datelor in fisierul random
dim1=size(date);
for k1=1:dim1(1)
fprintf(fid_scriere,'%s',date{k1,1});
fprintf(fid_scriere,'\n');
end

% preluarea datelor din fisierul random pentru clasificare KNN

[x y]=preiaDatelePtPrel(strcat(pwd,'\fisier_caracteristici_random.txt'));
[dim1,dim2]=size(x);

number = round(procent_invatare*dim1);

%xapp- matricea de antrenare

xapp=x(1:number,1:dim2-1);

%xtest- matricea de test

xtest=x(number+1:dim1,1:dim2-1);

%yapp- vectorul care contine clasele imaginilor de antrenare

yapp=y(1:number);

%ytest- vectorul care contine clasele imaginilor de testare

ytest=y(number+1:dim1);
%preluare valoare numar vecini
k=str2double(get(handles.edit4,'String'));

52
 tic
%clasificare KNNR
DS.input=xapp';
DS.output=yapp';
TS.input=xtest';
knnrParam.k=k;
try
[computedOutput] =knnr(DS, TS, knnrParam);
catch error
disp(error);
errordlg('Numar vecini prea mare sau prea mic setul de date de antrenare',...
'Error');

enableButtons2(handles);
end
% timpul de clasificare KNNR
timp=toc;
% calculare performante
accuracy=computeAccuracy(ytest,computedOutput)*100;
perf=timp*(1-accuracy/100);
% afisarea rezultatelor obtinute in EDITBOX-uri
set(handles.edit5,'String',num2str(accuracy));
set(handles.edit6,'String',num2str(timp));
set(handles.edit7,'String',num2str(perf));

fclose all;
enableButtons2(handles);

% hObject handle to pushbutton2 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

function edit5_Callback(hObject, eventdata, handles)

% hObject handle to edit5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit5 as text

% str2double(get(hObject,'String')) returns contents of edit5 as a double

% --- Executes during object creation, after setting all properties.

function edit5_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

53
% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function edit6_Callback(hObject, eventdata, handles)

% hObject handle to edit6 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit6 as text

% str2double(get(hObject,'String')) returns contents of edit6 as a double

% --- Executes during object creation, after setting all properties.

function edit6_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit6 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function edit7_Callback(hObject, eventdata, handles)

% hObject handle to edit7 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit7 as text

% str2double(get(hObject,'String')) returns contents of edit7 as a double

% --- Executes during object creation, after setting all properties.

function edit7_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit7 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

54
function edit8_Callback(hObject, eventdata, handles)
% hObject handle to edit8 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit8 as text

% str2double(get(hObject,'String')) returns contents of edit8 as a double

% --- Executes during object creation, after setting all properties.

function edit8_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit8 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% --- Executes during object creation, after setting all properties.

function radiobutton8_CreateFcn(hObject, eventdata, handles)
% hObject handle to radiobutton8 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% --- Executes during object deletion, before destroying properties.

function uipanel12_DeleteFcn(hObject, eventdata, handles)
% hObject handle to uipanel12 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% --- Executes during object deletion, before destroying properties.

function radiobutton8_DeleteFcn(hObject, eventdata, handles)
% hObject handle to radiobutton8 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% --- Executes on button press in pushbutton3 - creare vector trasaturi

function pushbutton3_Callback(hObject, eventdata, handles)
disableButtons(handles);
% numarul de clase utilizate pentru crearea vectorului de caracteristici
clasa1=get(handles.radiobutton3,'Value');
clasa2=get(handles.radiobutton4,'Value');
clasa3=get(handles.radiobutton5,'Value');
clasa4=get(handles.radiobutton6,'Value');

55
 %verificam sa nu avem selesctata numai o clasa
if (((clasa1) && ~(clasa2) && ~(clasa3) && ~(clasa4))||((clasa2) &&...
~(clasa1) && ~(clasa3) && ~(clasa4))||((clasa3) && ~(clasa1)...
&& ~(clasa2) && ~(clasa4))||((clasa4) && ~(clasa1) && ~(clasa2)...
&& ~(clasa3)))
errordlg('Trebuie sa selectati cel putin doua clase de imagini',...
'Error');
enableButtons1(handles);
end;
currentfolder=pwd;
% in functie de clasele selectate preluam imaginile din directorul
% corespunzator
if ((clasa1)&&(clasa2)&&(~(clasa3))&&(~(clasa4)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\persons\')};
clasa=[1,2];
elseif ((clasa1)&&(clasa3)&&(~(clasa2))&&(~(clasa4)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\animals\')};
clasa=[1,3];
elseif ((clasa1)&&(clasa4)&&(~(clasa2))&&(~(clasa3)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\garbage\')};
clasa=[1,4];
elseif ((clasa1)&&(clasa2)&&(clasa3)&&(~(clasa4)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\persons\'),strcat(currentfolder,'\animals\')};
clasa=[1,2,3];
elseif ((clasa1)&&(clasa2)&&(clasa4)&&(~(clasa3)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\persons\'),strcat(currentfolder,'\garbage\')};
clasa=[1,2,4];
elseif ((clasa1)&&(clasa3)&&(clasa4)&&(~(clasa2)))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\animals\'),strcat(currentfolder,'\garbage\')};
clasa=[1,3,4];
elseif ((clasa1)&&(clasa2)&&(clasa3)&&(clasa4))
dirImagini={strcat(currentfolder,'\cars\'),...
strcat(currentfolder,'\persons\'),...
strcat(currentfolder,'\animals\'),...
strcat(currentfolder,'\garbage\')};
clasa=[1,2,3,4];
elseif ((clasa2)&&(clasa3)&&(~(clasa1))&&(~(clasa4)))
dirImagini={strcat(currentfolder,'\persons\'),...
strcat(currentfolder,'\animals\')};
clasa=[2,3];
elseif ((clasa2)&&(clasa4)&&(~(clasa1))&&(~(clasa3)))
dirImagini={strcat(currentfolder,'\persons\'),...
strcat(currentfolder,'\garbage\')};
clasa=[2,4];
elseif ((clasa2)&&(clasa3)&&(clasa4)&&(~(clasa1)))
dirImagini={strcat(currentfolder,'\persons\'),...

56
 strcat(currentfolder,'\animals\'),strcat(currentfolder,'\garbage\')};
clasa=[2,3,4];
elseif ((clasa3)&&(clasa4)&&(~(clasa1))&&(~(clasa2)))
dirImagini={strcat(currentfolder,'\animals\'),...
strcat(currentfolder,'\garbage\')};
clasa=[3,4];
end;
% metodele folosite la formarea vectorului de trasaturi
met1=get(handles.radiobutton8,'Value');
met2=get(handles.radiobutton9,'Value');
met3=get(handles.radiobutton10,'Value');
met4=get(handles.radiobutton11,'Value');

metoda=[met1 met2 met3 met4];

handles.metoda=metoda;
numar_clase=size(clasa);
fis=fopen('fisier_caracteristici.txt','w');
tic
% extragerea trasaturilor din imaginile claselor selectate
for i=1:numar_clase(2)
numberOfLines = GiveNbOfLines(strcat('Lista.txt'));
fid_imagesLst=fopen(strcat('Lista.txt'));

for j=1:numberOfLines-1

imgName = numeImagine(fid_imagesLst);
% citesc imaginea, o transformam din color in gray
[imagine] = imread(strcat(dirImagini{i},imgName),'png');
imagine = im2double(imagine);
imagine=rgb2gray(imagine);

% aplicarea metodelor selectate asupra imaginilor din clasele selectate

vect_caract=extractie_vect_trasaturi(met1,met2,met3,met4,imagine);

clear imagine;
% salvam rezultatul in fisier
lungime=size(vect_caract,2);
for k=1:lungime
fprintf(fis,'%.3f,', vect_caract(k));
end;
fprintf(fis,'%d%c\n',clasa(i),',');
end;
progressbar(i/numar_clase(2));
end;
% timpul de extragere a caracteristicilor
timp=toc;
timestr = sec2timestr(timp);
% afisare timp
set(handles.edit9,'String',timestr);
enableButtons2(handles);
set(handles.radiobutton12,'Enable','on');
set(handles.radiobutton13,'Enable','on');

57
set(handles.pushbutton2,'Enable','on');
handles.output=hObject;
guidata(hObject, handles);

% hObject handle to pushbutton3 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

function edit9_Callback(hObject, eventdata, handles)

% hObject handle to edit9 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of edit9 as text

% str2double(get(hObject,'String')) returns contents of edit9 as a double

% --- Executes during object creation, after setting all properties.

function edit9_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit9 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function disableButtons(handles)
%change the mouse cursor to an hourglass
set(handles.figure1,'Pointer','watch');

%disable all the buttons so they cannot be pressed

set(handles.edit1,'Enable','off');
set(handles.edit4,'Enable','off');
set(handles.pushbutton1,'Enable','off');
set(handles.pushbutton2,'Enable','off');
set(handles.pushbutton3,'Enable','off');
set(handles.radiobutton3,'Enable','off');
set(handles.radiobutton4,'Enable','off');
set(handles.radiobutton5,'Enable','off');
set(handles.radiobutton6,'Enable','off');
set(handles.radiobutton8,'Enable','off');
set(handles.radiobutton9,'Enable','off');
set(handles.radiobutton10,'Enable','off');
set(handles.radiobutton11,'Enable','off');

function enableButtons1(handles)

58
%change the mouse cursor to an arrow
set(handles.figure1,'Pointer','arrow');

%enable all the buttons so they can be pressed

% set(handles.edit1,'Enable','on');
% set(handles.edit4,'Enable','on');
set(handles.pushbutton1,'Enable','on');
set(handles.pushbutton2,'Enable','on');
set(handles.pushbutton3,'Enable','on');
set(handles.radiobutton3,'Enable','on');
set(handles.radiobutton4,'Enable','on');
set(handles.radiobutton5,'Enable','on');
set(handles.radiobutton6,'Enable','on');
set(handles.radiobutton8,'Enable','on');
set(handles.radiobutton9,'Enable','on');
set(handles.radiobutton10,'Enable','on');
set(handles.radiobutton11,'Enable','on');

function enableButtons2(handles)
%change the mouse cursor to an arrow
set(handles.figure1,'Pointer','arrow');

%enable all the buttons so they can be pressed

set(handles.edit1,'Enable','on');
set(handles.edit4,'Enable','on');
set(handles.pushbutton1,'Enable','on');
set(handles.pushbutton2,'Enable','on');
set(handles.pushbutton3,'Enable','on');
set(handles.radiobutton3,'Enable','on');
set(handles.radiobutton4,'Enable','on');
set(handles.radiobutton5,'Enable','on');
set(handles.radiobutton6,'Enable','on');
set(handles.radiobutton8,'Enable','on');
set(handles.radiobutton9,'Enable','on');
set(handles.radiobutton10,'Enable','on');
set(handles.radiobutton11,'Enable','on');

% --- Executes on button press in pushbutton4 - preia imagine pentru

% clasificare
function pushbutton4_Callback(hObject, eventdata, handles)
% preluare imagine noua pentru clasificarea ei pe baza fisierului implicit
% sau obtinut online
cla(handles.axes1,'reset');
try
[imagine_init,map]=imread('no_image.jpg');
imshow(imagine_init,map,'parent',handles.axes1);
[filename, pathname] = uigetfile({'*.png';'*.jpg';'*.bmp';'*.*'}, 'Pick an Image File');
S = imread([pathname,filename]);
imshow(S,[0 255]);
handles.S = S;
catch error

59
 disp(error);
selection=questdlg('Nu a fost selectata nici o imagine.Stop proces?',...
'Stop process',...
'Yes','No','Yes');
switch selection,
case 'Yes'
[imagine_init,map]=imread('no_image.jpg');
imshow(imagine_init,map,'parent',handles.axes1);
set(handles.pushbutton5,'Enable','off');
return
case 'No'
pushbutton4_Callback(hObject, eventdata, handles);
return
end;
set(handles.pushbutton5,'Enable','on');
end;
set(handles.pushbutton5,'Enable','on');
handles.output=hObject;
guidata(hObject, handles);

% hObject handle to pushbutton4 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% --- Executes on button press in pushbutton5 - clasifica imagine

function pushbutton5_Callback(hObject, eventdata, handles)

S=handles.S;
S=im2double(S);
S=rgb2gray(S);
% fisier online sau implicit?
stare12=get(handles.radiobutton12,'Value');
stare13=get(handles.radiobutton13,'Value');
% in functie de optiunea selectata extrage caracteristicile de pe noua
% imagine si o clasifica
if (stare12)
tic
% extragere trasaturi
vect_caracteristici=extractie_vect_trasaturi(1,0,1,1,S);

timp1=toc;
set(handles.text41,'String',strcat(num2str(timp1),' s'));
%preia datele din fisierul implicit
[x y]=preiaDatelePtPrel(strcat(pwd,...
'\fisier_caracteristici_random_implict.txt'));
tic
% computedOutput=knnclassify(double(vect_caracteristici),xapp,yapp,1);
dim1=size(x);
x=x(:,1:dim1(2)-1);
% clasificare KNNR

60
 DS.input=x';
DS.output=y';
TS.input=double(vect_caracteristici)';
knnrParam.k=1;
[computedOutput] =knnr(DS, TS, knnrParam);
% timp clasificare
timp2=toc;
% afisarea rezultatelor obtinute - clasa, timp extractie trasaturi,
% timp clasificare
set(handles.text42,'String',strcat(num2str(timp2),' s'));
if (computedOutput==1)
clasa='Masini';
elseif (computedOutput==2)
clasa='Pietoni';
elseif (computedOutput==3)
clasa='Animale';
elseif (computedOutput==4)
clasa='Garbage';
end;
set(handles.text43,'String',clasa);
%
elseif (stare13)
tic
% extragerea trasaturilor noii imagini prin metodele selectate pentru
% formarea fisierului online
metoda=handles.metoda;
vect_caracteristici=extractie_vect_trasaturi(metoda(1),metoda(2),...
metoda(3),metoda(4),S);
% timp extractie trasaturi
timp1=toc;
set(handles.text41,'String',strcat(num2str(timp1),' s'));
% preia datele din fisierul obtinut online pentru clasificare
[x y]=preiaDatelePtPrel(strcat(pwd,'\fisier_caracteristici_random.txt'));
tic
% computedOutput=knnclassify(double(vect_caracteristici),xapp,yapp,1);
dim1=size(x);
x=x(:,1:dim1(2)-1);
% clasificare KNNR
DS.input=x';
DS.output=y';
TS.input=double(vect_caracteristici)';
knnrParam.k=1;
[computedOutput] =knnr(DS, TS, knnrParam);
% timp clasificare KNNR
timp2=toc;
% afisare timp clasificare in EDITBOX-ul aferent
set(handles.text42,'String',strcat(num2str(timp2),' s'));
% stabilirea clasei din care face parte imaginea de test
if (computedOutput==1)
clasa='Masini';
elseif (computedOutput==2)
clasa='Pietoni';

61
 elseif (computedOutput==3)
clasa='Animale';
elseif (computedOutput==4)
clasa='Garbage';
end;
set(handles.text43,'String',clasa);
end;

guidata(hObject, handles);
% hObject handle to pushbutton5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% --- Executes on button press in radiobutton12 - fisier implicit

function radiobutton12_Callback(hObject, eventdata, handles)
%setarea starilor ridiobutoanelor 12 si 13
stare13=get(handles.radiobutton13,'Value');
stare12=get(handles.radiobutton12,'Value');
if (stare12)
set(handles.radiobutton13,'Value',0);
elseif (stare13)
set(handles.radiobutton12,'Value',0);
elseif (~(stare12))
set(handles.radiobutton13,'Value',1);
end;

% hObject handle to radiobutton12 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hint: get(hObject,'Value') returns toggle state of radiobutton12

% --- Executes on button press in radiobutton13 - fisier obtinut online

function radiobutton13_Callback(hObject, eventdata, handles)
%setarea starilor ridiobutoanelor 12 si 13
stare13=get(handles.radiobutton13,'Value');
stare12=get(handles.radiobutton12,'Value');
if (stare13)
set(handles.radiobutton12,'Value',0);
elseif (stare12)
set(handles.radiobutton13,'Value',0);
elseif (~(stare13))
set(handles.radiobutton12,'Value',1);
end;

% hObject handle to radiobutton13 (see GCBO)

% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

62
% Hint: get(hObject,'Value') returns toggle state of radiobutton13

Codul Matlab pentru metodele de extragere folosite în aplicaţia GUI

function [vect_caracteristici1]=metoda1(imagine)

vect_wavelet=compresie_wavelet(imagine,3,'bior1.3');
% metoda I
% aplicare CombFirst4Moments, MultiscaleHistograms, TamuraTextures
% asupra transformatei wavelet a imaginii
first4moments = CombFirst4Moments(vect_wavelet);
multiscalehist = MultiScaleHistograms(vect_wavelet);
TamuraFeatures = TamuraTextures(vect_wavelet);
vect_caracteristici1=[first4moments,multiscalehist,...
TamuraFeatures];
clear first4moments;
clear multiscalehist;
clear TamuraFeatures;

function [vect_caracteristici2]=metoda2(imagine)
% aplicare fft asupra imaginii originale
% metoda II
fftTrans=FourierTransform(imagine);
% % aplicare CombFirst4Moments, MultiscaleHistograms, TamuraTextures
% % asupra transformatei wavelet a transformatei FFT
vect_wavelet=compresie_wavelet(fftTrans(:,:,1),3,'bior1.3');
first4moments = CombFirst4Moments(vect_wavelet);
multiscalehist = MultiScaleHistograms(vect_wavelet);
TamuraFeatures = TamuraTextures(vect_wavelet);
vect_caracteristici2=[first4moments,multiscalehist,...
TamuraFeatures];

clear first4moments;
clear multiscalehist;
clear TamuraFeatures;

function [vect_caracteristici3]=metoda3(imagine)
% % metoda III
% % aplicate CombFirst4Moments, MultiscaleHistograms, TamuraTextures si
% % transformata Radon asupra imaginii originale
first4moments = CombFirst4Moments(imagine);
multiscalehist = MultiScaleHistograms(imagine);
TamuraFeatures = TamuraTextures(imagine);
radonTrans = RadonTransformStatistics(imagine);
vect_caracteristici3=[first4moments,multiscalehist,...
TamuraFeatures,radonTrans];

clear first4moments;
clear multiscalehist;
clear TamuraFeatures;
clear radonTrans;

63
function [vect_caracteristici4]=metoda4(imagine)
% metoda IV
% % aplicare Zernike polinomials asupra imaginii originale
zvalues = ZernikePolynomials(imagine)*1000;
vect_caracteristici4=zvalues;

clear zvalues;

Codul Matlab pentru extracţia trăsăturilor din fiecare imagine în funcţie de metodele alese în
aplicaţia GUI

function [vect_caract]=...
extractie_vect_trasaturi(met1,met2,met3,met4,imagine)
% met1 - 0 1 daca metoda I este folosita pentru formarea vectorului de
% trasaturi
% met2 - 0 1 daca metoda II este folosita pentru formarea vectorului de
% trasaturi
% met3 - 0 1 daca metoda III este folosita pentru formarea vectorului de
% trasaturi
% met4 - 0 1 daca metoda IV este folosita pentru formarea vectorului de
% trasaturi
% vect_caract- vectorul de caracteristici obtinut in urma plicarii
% metodelor de extractie asupra imainii
if ((met1)&&(~(met2))&&(~(met3))&&(~(met4)))
vect_caract=metoda1(imagine);

elseif ((met2)&&(~(met1))&&(~(met3))&&(~(met4)))
vect_caract=metoda2(imagine);

elseif ((met3)&&(~(met1))&&(~(met2))&&(~(met4)))
vect_caract=metoda3(imagine);

elseif ((met4)&&(~(met1))&&(~(met2))&&(~(met3)))
vect_caract=metoda4(imagine);

elseif ((met1)&&(met2)&&(~(met3))&&(~(met4)))
vect_caract=[metoda1(imagine),metoda2(imagine)];

elseif ((met1)&&(met3)&&(~(met2))&&(~(met4)))
vect_caract=[metoda1(imagine),metoda2(imagine)];

elseif ((met1)&&(met4)&&(~(met2))&&(~(met3)))
vect_caract=[metoda1(imagine),metoda4(imagine)];

elseif ((met2)&&(met3)&&(~(met1))&&(~(met4)))
vect_caract=[metoda2(imagine),metoda3(imagine)];

elseif ((met2)&&(met4)&&(~(met1))&&(~(met3)))
vect_caract=[metoda2(imagine),metoda4(imagine)];

elseif ((met3)&&(met4)&&(~(met1))&&(~(met2)))

64
 vect_caract=[metoda3(imagine),metoda4(imagine)];

elseif ((met1)&&(met2)&&(met3))
vect_caract=[metoda1(imagine),metoda2(imagine),...
metoda3(imagine)];

elseif ((met1)&&(met2)&&(met4)&&(~(met3)))
vect_caract=[metoda1(imagine),metoda2(imagine),...
metoda4(imagine)];

elseif ((met1)&&(met3)&&(met4)&&(~(met2)))
vect_caract=[metoda1(imagine),metoda3(imagine),...
metoda4(imagine)];

elseif ((met2)&&(met3)&&(met4)&&(~(met1)))
vect_caract=[metoda2(imagine),metoda3(imagine),...
metoda4(imagine)];

elseif ((met1)&&(met2)&&(met3)&&(met4))
vect_caract=[metoda1(imagine),metoda2(imagine),...
metoda3(imagine),metoda4(imagine)];
end;

65