Documente Academic
Documente Profesional
Documente Cultură
Proiect de diplomă
CONDUCATOR, ABSOLVENT,
Prof. dr. ing. Gabriel OLTEAN Teodor Florin CIORTEA
2010
Locul de execuţie: Laboratorul de Sisteme cu Logică Nuanţată, sala 329, Str: George
Bariţiu 26-28
CONDUCĂTOR,
Prof. dr. ing. Gabriel OLTEAN
2
Declaraţia autorului
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 către mine.
ABSOLVENT,
Teodor Florin CIORTEA
3
1. Numele şi prenumele studentului: Teodor Florin CIORTEA
2. Numele şi prenumele conducătorului: Prof. dr. ing. Gabriel OLTEAN
ABSTRACT
Sorting systems with fuzzy logic is a modern solution to achieve decision-making systems
based on miscellaneous similar features of the objects. In this paper was done designing and
developing such a classification system, based on extraction of features and then use them to
achieve selection (decision). The entry of this system consists in color images of the objects
classified.
The application has a two-tier implementation. The first level is represented by the extraction
algorithms for the three characteristics (physical appearance, color, size), completed in Matlab
integrated development environment (IDE), and the second level consists in designing of a
Mamdani type fuzzy logic decision system, with three inputs, corresponding to the features of the
objects, and two outputs, wich means the type respectively the state of the object. Subsequently, is
made the connection between the sorting system and the input parameters from the processing
image corresponding algorithms. Since the system in question is a decisional one and not a control
one, the defuzzification method used is Mean of Maximum (MOM). Output values returned from
the defuzzification method, are correlated with appropriate words to display final results, results
that prove the correctness of the whole design and implementation process.
4
CURRICULUM VITAE
Studies:
2002 – 2006 : “Emil Racoviţa” Naţional College of Cluj-Napoca, Cluj
2002 – 2010 : Tehnical University of Cluj-Napoca,
Faculty of Electronics, Telecommunication and Information Technology,
Major course of study: Applied Electronics
Professional Activities:
2008 – August – technological practice (140 hours) at S.C.NET BRINEL S.A., Cluj-Napoca,
Maintenance and P.C. Assembling Departament
2009 – August – technological practice (120 hours) at S.C.NET BRINEL S.A., Cluj-Napoca,
Maintenance and P.C. Assembling Departament
Technical Knowledge:
PC Knowledge: - configuration of Windows system
- programming: C/C++, C#, Matlab
- known programs: OrCad, Matlab, Labview
Other skills: medium knowledges în computers networks
Foreign Languages:
Contact:
Adress: Avram Iancu St., No. 3, Ap. 17, Huedin, Cluj-Napoca
Phone: 0748-426680
E-mail: ciorteaflorin@yahoo.com
Subsemnatul Teodor Florin Ciortea, prin prezenţa declare că datele din acest Curriculum
Vitae pot fi folosite de către Facultatea de Electronică, Telecomunicaţii şi Tehnologia Informaţiei,
din cadrul Universităţii Tehnice din Cluj-Napoca în scopuri de promovare şi orientare în cariera
profesională, în următoarele condiţii:
- fără consultare prealabilă
5
- nu sunt de accord
Planificarea activităţii
Cuprins
Studiu bibliografic................................................................................................................................8
2. Fundamentare teoretica...................................................................................................................10
2.1. Metodologia propusa................................................................................................................11
2.2. Logica Fuzzy............................................................................................................................12
2.2.1. Mulţimile fuzzy.................................................................................................................12
2.2.2. Variabile lingvistice..........................................................................................................14
2.2.3. Grade de adevăr................................................................................................................14
2.2.4. Aplicarea valorilor de adevăr ...........................................................................................14
2.2.5. Raţionament fuzzy............................................................................................................15
2.2.6. Proprietăţile mulţimilor fuzzy...........................................................................................17
6
2.2.7. Sisteme cu logică fuzzy....................................................................................................18
2.2.8. Sisteme cu locica fuzzy Takagi-Sugeno...........................................................................19
2.2.9. Sistemele cu logică fuzzy Mamdani..................................................................................20
2.3. Mediul de programare MATLAB............................................................................................21
2.3.1. Image Acquizition Toolbox...............................................................................................22
2.3.2. Image Processing Toolbox................................................................................................22
2.3.3. Afişarea şi explorarea imaginilor......................................................................................23
2.3.4. Procesarea şi postprocesarea imaginilor............................................................................23
2.3.5. Proiectarea şi simularea sistemelor fuzzy în MATLAB cu Fuzzy Logic Toolbox...........23
2.3.6. Utilizarea Fuzzy Logic Toolbox........................................................................................24
2.3.7. Construirea unui sistem de inferenţă fuzzy.......................................................................24
2.3.8. Modelarea utilizând logică fuzzy......................................................................................26
2.3.9. Defuzzificarea...................................................................................................................26
3. Proiectare şi rezultate experimentale...............................................................................................29
3.1. Extragerea caracteristicilor obiectelor......................................................................................29
3.1.1. Achiziţia imaginilor ..........................................................................................................29
3.1.2. Algoritmul de detecţie a conturului...................................................................................30
3.1.3. Algoritmul de eliminare al umbrelor.................................................................................33
3.1.4. Algoritmul de detecţie a formei.........................................................................................37
3.1.5. Algoritmul de determinare a dimensiunii.........................................................................40
3.1.6. Algoritmul de detecţie a culorii........................................................................................41
3.1.7. Algoritmul de returnare a obiectelor şi a stării acestora ..................................................42
3.1.8. Funcţia principală.............................................................................................................44
3.2. Proiectarea Sistemului cu Logică Fuzzy în determinarea tipului fructului şi stării acestuia. . .45
3.2.1. Intrări.................................................................................................................................46
3.2.1.1. Definirea mulţimilor fuzzy pentru variabila de intrare aspect.......................................46
3.2.1.2. Definirea mulţimilor fuzzy pentru variabila de intrare dimensiune...............................47
3.2.1.3. Definirea mulţimilor fuzzy pentru variabila de intrare culoare......................................48
3.2.2. Ieşirile................................................................................................................................49
3.2.2.1. Definirea mulţimilor fuzzy pentru variabila de ieşire tipul fructului.............................49
3.2.2.2. Definirea mulţimilor fuzzy pentru variabila de ieşire a stării fructului..........................50
3.2.3. Definirea setului de reguli pentru SLF..............................................................................50
3.2.4. Funcţionarea sistemului cu logică fuzzy...........................................................................52
3.2.5. Rezultatele proiectării sistemului de sortare.....................................................................54
3.2.6. Defuzzificarea..................................................................................................................55
Concluzii.............................................................................................................................................56
5. Bibliografie......................................................................................................................................57
Index de imagini continute in text
Figura 1: Schemă logică pentru metodologia propusă...................................11
Figura 2: Ilustrarea mulţimilor “TRUE” şi “FALSE” în logica booleană (a) şi în logica fuzzy (b)...12
Figura 3: Cele 11 tipuri de mulţimi fuzzy...........................................................................................14
Figura 4: Inferenţa compoziţională.....................................................................................................17
Figura 5: Schema bloc a unui sistem cu logică fuzzy........................................................................19
Figura 6: Prelucrarea semnalelor într-un sistem cu logică fuzzy Takagi-Sugeno...............................20
Figura 7: Structura unui sistem cu logică fuzzy Mamdani..........................21
Figura 8: Interpretarea diagramei fuzzy de inferenţa de tip Mamdani................................................21
Figura 9: Editorul FIS..........................................................................................................................24
Figura 10: Editorul de funcţii membre................................25
7
Figura 11: Afişarea suprafeţelor.....................................................25
Figura 12: Metoda maximului funcţiei de apartenenţa.......................................................................27
Figura 13: Metoda centrului de masă..................................................................................................27
Figura 14: Metoda mediei ponderate...................................................................................................28
Figura 15: Metoda mediei maximelor.................................................................................................28
Figura 16: Rezultatul obţinut în urma rulării funcţiei “edge”..........................30
Figura 17: Rezultatul obţinut în urma rulării funcţiei “imdilate”.........................31
Figura 18: Rezultatul obţinut în urma rulării funcţiei “imfill”...............................31
Figura 19: Rezultatul final al aplicarii algoritmului................................32
Figura 20: Imaginea originală pe fundal negru (înainte de aplicarea algoritmului de eliminare a
umbrelor).............................................................................................................................................35
Figura 21: Imaginea fără umbre pe fundal negru (rezultată în urma aplicării algoritmului de
eliminare a umbrelor cu prag 15)........................................................................................................35
Figura 22: Imaginea originală pe fundal alb (înaintea de aplicarea algoritmului de eliminare a
umbrelor).............................................................................................................................................36
Figura 23: Imaginea fără umbre pe fundal alb (rezultată în urma aplicării algoritmului de eliminare a
umbrelor cu prag 90)...........................................................................................................................36
Figura 24: Imaginea fără umbre pe fundal alb (rezultată în urma.......................................................37
Figura 25: Obţinerea formei................................................................................................................38
Figura 26: Aplicarea conturului asupra formei...........................................38
Figura 27: Rezultatul final al algoritmului de determinare a formei...................................................39
Figura 28: Modelul sistemului fuzzy...................................................................................................46
Figura 29: Editarea Regulilor..............................................................................................................46
Figura 30: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Aspect..................47
Figura 31: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Dimensiune.....................48
Figura 32: Mulţimile fuzzy initiale peste universul discuţiei variabilei de intrare Culoare................49
Figura 33: Mulţimile fuzzy finale peste universul discuţiei variabilei de intrare Culoare..................49
Figura 34: Mulţimile fuzzy peste universul discuţiei variabilei de iesire TipFruct............................50
Figura 35: Mulţimile fuzzy peste universul discuţiei variabilei de iesire StareFruct..........................50
Figura 36: Fereastra Rule Viewer.................................................53
Figura 37: Ieşirea TipFruct în funcţie de întărările Aspect şi Dimensiune...................54
Figura 38: Ieşirea StareFruct în funcţie de intrările Dimensiune şi Culoare..................54
iografic
Sistemele de sortare implementate în diferite moduri, prin utilizarea a diferiţi algoritmi, unii
deja consacraţi, precum Bubblesort (sortare prin metoda bulelor) sau Mergesort (sortare prin
interclasare), sunt cu succes folosiţi în procesele manageriale ale bazelor de date. Lucrarea de faţă se
bazează pe studiul şi implementarea unui sistem de clasificare bazat pe logică fuzzy, aplicat asupra
unui set de imagini color, în vederea selecţiei obiectelor conţinute în imaginile respective pe baza
unor trăsături asemănătoare (aspect fizic, dimensiune, culoare).
Teoria mulţimilor fuzzy a fost dezvoltată începând din anii ’60, ca un răspuns la insuficienta
consistenţă a raţionamentelor deterministe de tipul “DA” sau “NU”, încercându-se formalizarea
unor raţionamente de tipul “Mai mult sau mai puţin”.
În logica clasică, propoziţiile pot fi adevărate sau false, neexistând posibilitatea unor valori
intermediare. În cazul abordării unor modele concrete, din lumea reală, s-a constatat apariţia unor
8
situaţii delicate: nu toate sistemele reale sunt clare şi deterministe (ca atare nu pot fi descrise cu
exactitate pe baza logicii clasice), iar descrierea completă a unui sistem real necesită o serie de
informaţii care nu sunt cunoscute sau furnizate complet şi, de multe ori, nu sunt înţelese exact.
Astfel a apărut ca necesară utilizarea mulţimilor fuzzy şi a logicii rezultată din utulizarea
mulţimilor fuzzy în locul mulţimilor clasice, crisp.
Teoria mulţimilor fuzzy a fost dezvoltată de Lotfi Zadeh care a observat ca modelele
matematice şi diferite modele clasice în fundamentarea procesului decisional prezintă imperfecţiuni
şi sunt dificil de aplicat la realitatea complexă a factorilor economici. Pe măsură ce creşte
complexitatea unui process economic se poate ajunge la un punct critic, de la care precizia şi
semnificaţia afirmaţiilor referitoare la comportamentul procesului sunt incompatibile. Principiul
incompatibilităţii definit de Zadeh converge spre afirmaţii vagi (fuzzy), iar logica fuzzy încearcă să
creeze un formalism pentru imprecizia şi ambiguitatea specifică limbajului natural.[5]
Adoptarea de decizii superior şi complex fundamentate devine posibilă prin apelarea la o
gamă variată de metode şi tehnici decizionale care facilitează alegerea variantei optime, fiecare
dintre acestea încadrându-se într-un anumit model decizional. Funcţie de volumul, structura şi
calitatea informaţiilor de care se beneficiază, modelele decizionale pot fi: deterministe, centrate pe
informaţii cu grad ridicat de precizie, completă; nedeterministe şi probabiliste. Utilizarea acestor
metode şi tehnici decizionale determină o sporire a gradului de rigurozitate şi, implicit, de eficacitate
a deciziilor adoptate, diferenţiate în raport de tipologia situaţiilor decizionale implicate.
Modelele bazate pe teoria mulţimilor vagi, în care informaţiile transmise conducerii pentru
fundamentarea deciziilor sunt cu grad ridicat de completitudine, dar mai puţin precise, modele
probabiliste, utilizate în situaţia existenţei unor informaţii precise, dar mai puţin complexe, precum
şi modelele deterministe sunt, în opinia noastră, cele mai semnificative.
Metodele şi tehnicile decizionale se pot grupa, în funcţie de tipul situaţiilor decizionale
implicate, în trei categrii:
- metode şi tehnici de optimizare a deciziilor în condiţii de certitudine: ELECTRE, metoda
utilităţii globale, metoda activă, algoritmul lui Deutch-Martin, tabelul decizional,
simularea decizională;
- metode şi tehnici de optimizare a deciziilor în condiţii de incertitudine: tehnica optimistă,
tehnica pesimistă (A.Wald), tehnica optimalitatii (C.Hurwicz), tehnica proporţionalităţii
(Bayes-Laplace), tehnica minimizării regretelor (L.Savage)
- metode şi tehnici de optimizare a deciziilor în condiţii de risc: arborele decizional,
metoda speranţei matematice.
Sistemului decizional implementat în această aplicaţie se înscrie în prima categorie deoarece valorile
setului de intrare reprezintă certitudini, în funcţie de care, în urma operaţiilor fuzzy, a implicaţiei, a
operaţiei de agregare şi a celei de defuzzificare, rezultă la ieşire o singură valoare tranşantă. Iniţial
pentru ieşiri tranşante în cazul sistemelor decizionale se folosesc sisteme fuzzy de tip Takagi-
Sugeno, a căror ieşire reprezintă un singur punct cu grad de apartenenţa 100% (singleton), însă în
cazul de faţă s-a definit un sistem fuzzy de tip Mamdani a cărei ieşire este reprezentat tot de mulţimi
fuzzy fiecare cu un anumit grad de activare, în final aplicându-se o metodă de defuzzificare de tip
medie a maximelor. Este aleasă această metodă de defuzzificare deoarece sistemul la care ne referim
este un sistem decizional şi nu unul de control.[6]
În cea ce priveşte partea de procesare de imagini, cel mai mare impediment întâlnit este
reprezentat de prezenţa umbrelor în imaginile realizate şi realizarea conturului. În ceea ce priveşte
eliminarea umbrelor , problema a fost rezolvată prin implementarea unei idei proprii, ce presupune
setarea unui prag, realizare unei diferenţe, în modul, între valorile pixelilor suprapuşi corespunzători
celor trei planuri luate două câte două, şi compararea maximului dintre cele trei rezultate cu pragul.
În cazul în care pragul este mai mare pixelul respectiv este considerat umbră şi ia valoarea standard
a pixelului de fundal.
9
În cazul realizării conturului şi determinării, formei Matlab Image Processing Toolbox oferă
doi algoritmi deosebit de eficienţi în acest sens, care vor fi explicaţi în detaliu în secţiunile
corespunzătoare. Alte metode de determinare a conturului sunt reprezentate de aplicarea
transformatelor cosinus şi a transformatei wavelet. Transformata wavelet reprezintă în fapt o metodă
foarte eficientă de detecţie a conturului. Fiecărui coeficient al acestei transformate îi corespunde un
pixel din imagine. Aceşti coeficienţi sunt reprezentaţi într-o matrice în care elementele de deasupra
diagonalei secundare corespund cu cele mai înalte frecvenţe întâlnite pe imagine. Aceste frecvenţe
corespund contururilor care por fi determinate efectuaind o serializare a matricelor urmată de o
normalizare. De asemenea această metodă este foarte folosită în cazul marcărilor transparente ale
imaginilor ce presupune includerea unui mesaj ascuns în contururile întâlnite într-o imagine.
2. Fundamentare teoretica
Logica fuzzy a devenit o soluţie foarte promiţătoare pentru realizarea sistemelor decizionale.
Tema acestei lucrări propune proiectarea eficientă a unui sistem de sortare implementat pe baza
logicii fuzzy. Pentru modelarea sistemului de clasificare şi a algoritmilor de extragere a
proprietăţilor obiectelor s-a folosit mediul de dezvoltare integrat Matlab, şi mai exact Image
Processing Toolbox, şi Fuzzy Logic Toolbox.
10
2.1. Metodologia propusa
11
2.2. Logica Fuzzy
Logica Fuzzy (din engl.: logică vagă) este o formă de logică multi-valorica derivată din setul
teoretic fuzzy, folsită pentru concluzionarea unor propoziţii ale căror valoare de adevăr este mai
mult aproximativă decât precisă. Spre deosebire de logica clasică, care lucrează cu două valori
numerice exacte (0 pentru fals şi 1 pentru adevărat), logica fuzzy foloseşte o plajă continuă de valori
logice cuprinse în intervalul [0;1], unde 0 indică falsitatea completă, iar 1 indică adevărul complet.
Astfel, dacă în logica clasică un obiect poate aparţine (1) sau nu (0) unei mulţimi date, în logica
fuzzy putem defini gradul de apartenenţă al obiectului la mulţime care poate lua valori între 0 şi 1.
Mai mult, atunci când sunt folosite variabile lingvistice, gradele de apartenenţa pot fi controlate prin
funcţii specifice.
Diferenţă esenţială dintre logica clasică şi cea fuzzy, este faptul că legea “terţului exclus",
defnită de Aristotel, nu mai este valabilă. În Figura 2. de mai jos este ilustrată diferenţa între logica
booleană şi cea fuzzy. Dacă în primul caz există o delimitare clară între cele două valori de adevăr,
în al doilea caz există o zonă de nedeterminare, în care valoarea de adevăr poate fi 0 şi 1 în acelaşi
timp, într-o anumită măsură dată de gradul dapartenenta.
Figura 2: Ilustrarea mulţimilor “TRUE” şi “FALSE” în logica booleană (a) şi în logica fuzzy
(b)
Logica Fuzzy a luat naştere în 1965 ca o consecinţă a setului de teorii fuzzy propus de
profesorul Lotfi Zadeh de la Universitatea Berkeley din California. Cu toate că logica fuzzy a fost
aplicată în mai multe câmpuri, de la teoria controlului la inteligenţă artificială, aceasta rămâne un
subiect controversat în cele mai multe statistici, care preferă logica booleană, sau de către unii
ingineri de control, care preferă lucrul cu două valori logice.
Logica fuzzy poate fi folosită atunci când nu există o delimitare clară între mulţimile ce
reprezintă valorile unei mărimi sau proprietăţi, sau evenimentele ori stările posibile ale unei
variabile aleatoare.
12
A = {µ A ( x) / x}
unde µ A ( x) reprezintă funcţia caracteristică sau funcţia de apartenenţa a lui x la mulţimea A.
Semnul ”/" este folosit doar pentru a delimita valoarea reală x de valoarea funcţiei de apartenenţa
µ A ( x) .
Funtia de apartenenţa se defineşte pe intervalul de valori posibile ale lui x cu valori reale, în
intervalul [0,1]: µ A ( x) → [0; 1].
Dacă A conţine doar 0 şi 1, atunci A nu mai este o mulţime fuzzy, ci una caracteristică
logicii clasice. Dacă funcţia de apartenenţa este discretă, atunci mulţimea A se scrie ca:
n
A = µ1 / x1 + µ 2 / x2 + ... + µ n / xn = ∑µ
i =1
i / xi
Dacă funcţia de apartenenţa este o funcţie continuă, atunci mulţimea fuzzy A se scrie ca:
A = ∫ µ A ( x) / x
X
4. Gradul de apartenenţa µ = : arată masura în care un element aparţine unei mulţimi fuzzy, µ ∈
[0;1]
µ A ( x) : X → [0;1]
A = {( x, µ A ( x )) | x ∈ X }
Funcţiile de apartenenţa pot fi de mai multe tipuri. De exemplu, în toolboxul de Fuzzy Logic
din Matlab sunt implementate 11 tipuri de mulţimi fuzzy reprezentate în Figură 3. Acestea sunt
triunghiulare (trimf), trapezoidale (tramf), de tip Gauss (gaussmf şi gauss2mf), clopot generalizat
(gbellmf), sigmoidale (sigmf, dsigmf, psigmf) şi curbe polinomiale (zmf, pimf, smf).
Un tip special de mulţime fuzzy este mulţimea de tip “singleton” a cărei funcţie de
apartenenţa are valoarea 1 doar într-un punct particular şi valoarea 0 în rest. [1]
13
Figura 3: Cele 11 tipuri de mulţimi fuzzy
Logica fuzzy şi logica probalisică sunt similare din punct de vedere matematic, ambele
având grade de adevăr cuprinse în intervalul 0-1, dar conceptual sunt diferite, datorită interpretărilor
diferite. Logica fuzzy corespunde unor “grade de adevăr”, în timp ce logică probalistică corespunde
“probabilităţii, posibilităţii”. Consecvent, probabilitatea nu are nimic în comun cu fuzzificarea,
acestea sunt concepte diferite care la o privire superficială par similare din cauza folosirii aceluiaşi
interval de valori numerice reale, [0;1]. Totuşi, din moment ce teoreme, precum cea a lui De
Morgan, au aplicabilităţi duale, şi proprietăţile variabilelor aleatoare sunt similare cu proprietăţile
stărilor logice binare, se pot observa cazurile în care ar putea apărea confuzii.
14
O aplicaţie de bază ar putea caracteriza gamele de variaţie pentru o variabilă continuă. De
exemplu, măsurarea temperaturii pentru împiedicarea blocării frânelor unui automobil poate avea
mai multe funcţii membre separate, definind intervale de temperatură particulare necesare pentru
controlul corespunzător al frânelor. Fiecare funcţie indică aceeaşi valoare a temperaturii către o
valoare de adevăr în intervalul [0;1].
15
premisă este ∗
implicaţie DACĂ este ATUNCI este
concluzie bbbbbbberww n
concluzie este ∗
∗ ∗
unde A şi B sunt mulţimile fuzzy A şi B modificate.
∗
Aflarea concluziei B se realizează în urma procesului de inferenţă (deducţie) fuzzy, care
matematic se poate rezolva folosind regula compoziţională de inferenţă propusă de Zadeh:
B∗ = A∗ o ( A →B)
unde: “→” simbolizează operaţia de implicaţie (evaluarea regulii fuzzy);
“o” simbolizează operaţia de compunere a celor două propoziţii fuzzy din MPG.
Folosind funcţiile de apartenenţă avem:
µ B∗ ( y ) = µ A∗ ( x) oµ A→ B ( x, y )
Trebuie stabiliţi operatorii pentru cele două operaţii: implicaţie şi compunere. Pentru
implicaţie cei mai folosiţi operatori sunt:
min µ A→ B ( x, y ) = min( µ A ( x ), µB ( y ))
(Mamdani)
produs µ A→ B ( x, y ) = µ A ( x ) ⋅ µB ( y )
(Larsen)
Pentru compunere cel mai des se foloseşte compunerea max-min:
µ B∗ ( y ) = max min{µ A∗ ( x), µ A→ B ( x, y )} , ∀y ∈ V
∀x ∈ X
unde X şi V sunt universurile discuţiei pentru cele două variabile, x respectiv y .
Folosirea compunerii max-min împreună cu implicaţiile min sau produs conduc la cele mai
folosite mecanisme de inferenţă compoziţională:
• Inferenţa compoziţională max-min, sau Mamdani
µ B∗ ( y ) = max min{µ A∗ ( x), µ B ( y ))} , ∀y ∈ V
∀x ∈ X
• Inferenţa compoziţională max-produs, sau Larsen
µ B∗ ( y ) = max min{µ A∗ ( x), µ A ( x) ⋅ µB ( y )} , ∀y ∈ V
∀x ∈ X
A * este o mulţime fuzzy rezultată în urma unui proces de fuzzificare (ce se va discuta în
paragraful următor) şi de cele mai multe ori este o mulţime fuzzy singleton. Inferenţa
compoziţională este ilustrată în Figura 4, pentru trei tipuri de inferenţe: Mamdani, Larsen şi Takagi-
Sugeno. Având în vedere cazul particular de mulţime fuzzy singleton pentru A *, inferenţa
compoziţională max-min se reduce la formula:
µ B∗ ( y ) = min{µ A∗ ( x∗ ), min( µ A ( x), µ B ( y ))} , ∀y ∈ V
µ B∗ ( y ) = min{min( µA∗ ( x∗ ), µ A ( x), µB ( y )} , ∀y ∈ V
În cazul în care mulţimea fuzzy B este de tip Takagi-Sugeno de ordin zero (mulţime fuzzy
16
singleton) indiferent de operatorul folosit pentru operaţia de compunere, rezultă inferenţa
compoziţională Takagi-Sugeno.[1]
Normalitatea. O mulţime fuzzy este normală dacă valoarea maximă afunctiei de apartenenţa
este 1:
∨ x µ ( x) = 1
unde ∨ x reprezintă supremul sau maximul lui µ x . În caz contrar vom spune că mulţimea este
subnormală.
Convexitatea. O mulţime fuzzy A este convexă dacă şi numai dacă mulţimile Aα definite
ca:
17
Aα = {x | µ A ( x ) ≥ α }
Punctul “crossover”. Pentru o mulţime A punctul “crossover” este elementul pentru care
funcţia de apartenenţa are valoarea 0,5.
Valori singulare fuzzy. O valoare singulară (engl. singleton) este o mulţime fuzzy care are
un grad de apartenenţa pentru o singură valoare. Fie A o valoare singulară pentru un interval X ,
x ∈ X , atunci A poate fi scrisă ca: A = µ / x
În Figura 5. este prezentată structura unui SLF. Specific acestei structuri este lipsa fluxului
informaţional de la Baza de cunoştinţe, atât înspre interfaţa de Fuzzificare cât şi înspre interfaţa de
Defuzzificare
Baza de
cunoştinţe
informaţion
flux
mulţimi şi
reguli fuzzy
x* A* B* Defuzzificar y*
Fuzzificare Inferenţă
e Valori
Valori
tranşante tranşan
de intrare te de
flux de calcul ieşire 18
Figura 5: Schema bloc a unui sistem cu logică fuzzy
În prezent există două tipuri de SLF: de tip Mamdani şi de tip Takagi-Sugeno. Ele diferă în
principal prin partea de concluzie a regulilor fuzzy. Sistemele Mamdani x2 utilizează mulţimi fuzzy
obişnuite, pe când sistemele Takagi-Sugeno (T-S) folosesc în concluzie funcţii (liniare) a
variabilelor de intrare.
Fluxul de date dintr-un SLF este prezentat grafic în Figura 6. Valorile tranşante x1 * şi x2 *
ale variabilelor de intrare sunt fuzzificate rezultând mulţimile fuzzy singleton A1 *, respectiv A2 *.
Gradele de activare (adevăr) ale celor două reguli sunt µ1 , respectiv µ 2 şi sunt valori intermediare
folosite în cadrul inferenţei. Menţionăm că regula R2 este o regulă compusă conţinând în partea de
premisă ambele variabile legate prin conectivul fuzzy ŞI. Pentru conectivul ŞI este folosit operatorul
“min”. Valorile fuzzy parţiale ale variabilei de ieşire furnizate de cele două reguli sunt B1 * şi B2 * în
cazul unui SLF T-S de ordin zero, respectiv y1 * şi y2 * în cazul unui SLF T-S de ordin unu. Aceste
valori parţiale sunt agregate şi apoi defuzzificate folosind metoda de defuzzificare numită medie
ponderată. În urma defuzzificării se obţine valoarea tranşantă y * a variabilei de ieşire
corespunzătoare valorilor tranşante x1 * şi x2 * ale celor două variabile de intrare.[1]
19
Figura 6: Prelucrarea semnalelor într-un sistem cu logică fuzzy Takagi-Sugeno
Metoda de inferenţă mamdani este cea mai des folosită în metodologia fuzzy. Această
metodă a fost de departe cea dintâi metodă de control utilizând logică fuzzy. A fost propusă în 1975
de către Ebrahim Mamdani într-o încercare de a controla o combinaţie între un motor pe bază de
abur şi un boiler prin sintetizarea unui set de control cu reguli lingvistice obţinut pe bază de
axperimentare. Efortul lui Mamdani a fost bazat pe teoriile lui Lotfi Zadeh privitoare la algoritmii
fuzzy pentru sisteme complexe şi procese decizionale. Structura unui sistem cu logică fuzzy de tip
Mamdani este afişată în Figură 7.
Inferenţa de tip Mamdani, Figura 8, presupune că funcţiile member de ieşire să fie mulţimi
fuzzy. După finalizarea procesului de agregare, există o mulţime fuzzy pentru fiecare variabilă de
ieşire care necesită defuzzificare. Este posibil, şi în multe cazuri mult mai eficient, să folosim un
singur vârf ca ieşire a funcţiilor member decât un set de mulţimi fuzzy distribuite. Acest tip de
ieşire poartă numele de ieşire a funcţiilor member “singleton”, şi poate fi gândit că un set fuzzy pre-
defuzzificat. Ea îmbunătăţeşte eficienţa procesului de defuzzificare, deoarece simplifică modul de
calcul cerut de metoda mult mai generală Mamdani, care determină centrul de greutate a unei funcţii
bidimensionale. Mai degrabă decât integrarea în funcţia bidimensională pentru a determina centrul
de greutate, putem folosi o medie ponderată pentru câteva puncte date.
20
Figura 7: Structura unui sistem cu logică fuzzy Mamdani
MATLAB (de la Matrix Laboratory) este un mediu de dezvoltare pentru calcul numeric şi
analiză statistică care conţine limbajul de programare cu acelaşi nume, creeat de MathWorks.
MATLAB permite manipularea matricilor, vizualizarea funcţiilor, implementarea algoritmilor,
crearea de interfeţe şi poate interacţiona cu alte aplicaţii.
Este un limbaj interactiv de nivel superior care permite realizarea unor cerinţe de calcul
dificile cu o viteză de lucru mai ridicată decât cea a limbajelor de programare tradiţionale, precum
C, C++ sau Fortran. Chiar dacă e specializat în calcul numeric, există pachete care îi permit să
21
interacţioneze cu motoarele de calcul simbolic gen Maple. Un pachet adiţional, Simulink, oferă
posibilitatea de a realiza simulări ale sistemelor dinamice şi îmbarcate utilizând modele matematice.
MATLAB e utilizat pe larg în industrie, în universităţi şi e disponibil cross-platform, sub diverse
sisteme de operare: Windows, GNU/Linux, UNIX şi Mac OS.
MATLAB pune la dispoziţia utilizatorului un set de Toolbox-uri specializate pentru
rezolvarea diverselor cerinţe în cel mai optim mod. Astfel, în cea ce priveşte preluarea şi procesarea
imaginilor avem definite două toolbox-uri şi anume: Image Acquizition şi Image Processing. Acest
mediu suportă date standard şi formate de imagine, incluzând JPEG, JPEG-2000, TIFF, PNG, HDF,
HDF-EOS, FITS, Microsoft Excel, ASCII şi fişiere binare. De asemenea, acesta suportă formate de
imagini multibandă BIP şi BIL, precum cele utilizate de LANDSAT, de exemplu. Nivelul jos de
intrări/ieşiri şi funcţiile de mapare a memoriei oferă posibilitatea de a dezvolta rutine client pentru a
opera cu orice format de date.
Împreună, cele două toolboxuri promovate de MATLAB, oferă un mediu complet pentru
dezvoltarea aplicaţiilor cu imagini personalizate. [3]
22
2.3.3. Afişarea şi explorarea imaginilor
Image Procesing Toolbox ramifică grafica MATLAB pentru a oferi capabilităţi de afişare
personaliizata ale imaginilor. Se pot creea afişaje cu imagini mulltiple într-o singură fereastră,
afişaje adnotate cu text şi grafice, şi crearea de afisaaje specializate precum histogramele, profilele şi
conturarea subiectelor.
Algoritmii de detecţie a conturului permit determiarea marginilor unui obiect conţinut într-o
imagine. Aceşti algoritmi includ metodele Sobel, Prewitt, Roberts, Canny şi Laplasian din Gaussian.
Metoda Canny care este foarte performanţă poate determină contururi foarte slabe fără a fi influenţă
de zgomot.
23
2.3.6. Utilizarea Fuzzy Logic Toolbox
Acest toolbox oferă interfeţe grafice ce permit dezvoltarea de sisteme fuzzy clasice şi moduri
de recunoaştere. Folosind toolboxul se pot realiza sisteme de inferenţă fuzzy, sisteme de inferenţă
neurofuzzy adaptive şi clasificări fuzzy. Suplimentar, acesta oferă un controller-bloc fuzzy care
poate fi folosit în Simulink pentru modelarea şi simularea sistemelor fuzzy de control logic. Din
Simulink se poate genera cod în limbajul de programare C pentru a fi folosit în aplicaţii imbricate ce
include logică fuzzy.
Inferenţa fuzzy este o metodă de interpretare a vectorului de intrare, bazată pe reguli definite
de utilizator, şi asignarea de valori vectorului de ieşire. Utilizând interfeţele grafice de editare şi
afisre conţinute în Fuzzy Logic Toolbox, se poate defini setul de reguli, a funcţiilor membre şi
analiza comportamentul unui sistem de inferenţă fuzzy. Următoarele interfeţe de editare şi afişare
sunt oferite:
24
Figura 10: Editorul de funcţii membre
• Rule Editor (Editorul Regulilor) – permite afişarea şi editarea de reguli fuzzyfolosind unul
din cele trei formate: sintaxa full-English, notaţie simbolică concisă, sau notaţie indexată.
Fuzzy Logic Toolbox permite aplicarea tehnicilor de clasificare şi neurofuzzy pentru diverse
mdele şi clasificarea comportamentelor sistemelor.
Inferenţa neurofuzzy adaptivă
Utilizând Sistemul de Inferenţă Adaptivă Neurofuzzy (ANFIS) se pot forma funcţii membre
prin instruirea acestora cu date de intrare/ieşire, mai degrabă decât specificându-le manual.
Toolboxul foloseşte un algoritm de post-propagare singular sau în combinaţie cu metoda pătratelor
mai mici, capabilizand sistemul fuzzy să înveţe pe parcurs de la date.
Clasificarea fuzzy
Fuzzy Logic Toolbox oferă suport pentru metoda de clasificare “fuzzy C-means” şi pentru
clasificarea substractivă precum şi tehnici de modelare pentru clasificarea datelor.Fuzzy C-means
este o metodă de clasificare a datelor în care fiecare obiect aparţine unei clase într-un anumit grad
specificat de gradul de apartenenţa. Este o metodă care arăta cum să se grupeze obiectele ce
populează un spaţiu multidimensional într-un număr specificat de clase diferite. Funcţia “fcm” din
Fuzzy Logic Toolbox porneşte cu o estimare iniţială a centrelor de clase, menite să marcheze locaţia
medie a fiecărei clase. De obicei, estimarea iniţială acentrelor este cel mai probabil incorectă. În
plus, “fcm” atribuie (aleator) fiecărui obiect un grad de apartenenţa la fiecare clasă. Prin actualizarea
iterativă a centrelor claselor şi a gradelo de apartenenţa a tuturor obiectelor “fcm” deplasează iterativ
centrele claselor în locaţiile cele mai potrivite setului de date. Această iterare (optimizare) se
bazează pe minimizarea unei funcţii obiectiv ce reprezintă suma distanţelor de la fiecare obiect la un
centru de clasă, ponderat cu gradul de apartenenţa al acelui obiect la acea clasă. [7]
2.3.9. Defuzzificarea
funcţia de apartenenţa îşi atinge maximul într-un singur punct, valoarea reprezentativă a funcţiei de
apartenenţa se consideră ca fiind valoarea variabilei ( x∗ ) pentru care se atinge maximul respectiv.
26
Figura 12: Metoda maximului funcţiei de apartenenţa
b) Metoda (abscisei) centrului de masă este una dintre cele mai utilizate metode de defuzzificare
27
c) Metoda mediei ponderate este aplicabilă pentru funcţii de apartenenţa simetrice, fiind prezentată
în Figură 14 din care rezultă că valoarea defuzzificata se obţine prin ponderarea valorilor funcţiilor
a+b
d) Metoda mediei maximelor presupune calculul lui x∗ (Figura 15) unde: f ( µ ( x )) =
−1
28
3. Proiectare şi rezultate experimentale
Tema proiectului tratează un sistem de sortare bazat pe logică fuzzy. Aplicaţia a fost
realizată în mediul de programare MATLAB, utilizând toolboxurile pentru achiziţie şi procesare de
imagini, precum şi toolboxul dedicat logicii fuzzy. Etapele urmate pentru realizarea acestei teme au
fost preluarea imaginii cu o cameră foto şi încărcarea ei în matlab, extragerea caracteristicilor
obiectului (Culoare, Aspect, Dimensiune), realizarea unui sistem decizional cu logică fuzzy şi
introducerea caracteristicilor obţinute anterior şi clasificarea obiectului pe baza caracteristicilor
extrase utilizând algoritmul de clasificare fuzzy. De asemenea, de menţionat ca obiectele folosite în
experimentare sunt fructe, iar pozele au fost realizate folosind un fundal negru şi o distanţă standard
de aproximativ 90 cm.
În cazul în care achiziţia nu se face în timp real, de la o cameră web spre exemplu, încărcarea
imaginilor în Matlab se realizează relativ simplu prin intermediul funcţiei “imread”. În fragmentul
de cod afişat mai jos, partea comentată, reprezintă implementarea modului de achiziţie a unor
imagini în timp real de la dispozitive precum camere web sau alt tip de camere, asupra cărora
mediul de dezvoltare integrat (IDE) Matlab, oferă compatibilitate. Funcţia “videoinput” realizează
achiziţia de la dispozitivul respectiv în funcţie de anumiţi parametrii şi anume:
(ADAPTORNAME, DEVICEID, FORMAT), unde primul parametru reprezintă un şir de caractere
text ce indică numele adaptorului folosit pentru comunicarea cu dispozitivul, al doilea parametru
reprezintă o valoare numerică scalară ce identifică un anumit dispozitiv disponibil prin adaptorul
specificat, iar cel din urmă este un şir de caractere ce specifică un format video particular suportat de
către dispozitiv sau intreaga cale de directoare de configurare a dispozitivului. Funcţia “preview” cu
un singur parametru realizează o fereastră de previzualizare video care afisaza filmări în timp real
pentru dispozitivul de achiziţie. În final, funcţia “getsnapshot” returnează, imediat, un singur cadru
al imaginii primite de la dispozitivul de achiziţie. Secvenţa “pause” implică o procedură de oprire a
funcţiei în derulare şi aşteptarea apăsării unei taste de către utilizator pentru reluarea acesteia.
function [img] = achizitie()
% vidobj = videoinput('winvideo', 1, 'RGB24_640x480');
% preview(vidobj);
% pause;
% img = getsnapshot(vidobj);
img = imread('cireasa.jpg');
29
3.1.2. Algoritmul de detecţie a conturului
Imaginile preluate cu aparatul foto sunt imagini color, astfel ele vor fi prelucrate în paleta de
culori RGB. Reprezentarea primară a imaginilor color se realizează în spaţiul (R,G,B) (spaţiu numit
al componentelor primare de culoare: roşu, verde şi albastru, prin a căror combinare aditivă
ponderată putem obţine orice culoare din spectru). Acest model este văzut că o suprapunere de trei
planuri, planul Roşu, planul Verde şi planul Albastru, fiecare dintre cele trei planuri conţinând un
pixel din culoarea respectivă ce defineşte o anumită intensitate a nuanţei. Intervalul de valori pe care
sunt definiţi pixelii este [0,255]. Prin combinarea acestor planuri se obţine orice culoare posibilă.
Imaginea utilizată în acest algoritm este imaginea originală, realizată cu aparatul foto.
Această imagine trebuie transformată în nivele de gri pentru a fi posibilă aplelarea funcţiei “edge”.
Observăm în script definirea unui prag, returnat de funcţia “edge”, funcţie ce aplică o aproximare de
tip “roberts” asupra imaginii în nivele de gri. Metoda “roberts” returneaza contururile acelor puncte
din imagine unde gradientul este maxim. Ulterior, se setează un factor utilizat pentru detectarea
posibilelor contururi. Valoarea acestuia a fost determinată experimental, astfel încât să fie
îndeplinite două cerinţe de baza privitoare la acest aspect şi anume: acest factor trebuie să aibe o
valoare suficient de mică pentru a menţine timpi de rulare a algoritmului cât mai scurţi posibili, iar
pe de altă parte valoarea lui trebuie să fie suficient de mare pentru a începe realizarea detecţiei
contururilor de la cele mai fine detalii întâlnite în imaginea în nivele de gri. Ulterior se vor iniţializa
două variabile: “arie”, care în urma incrementării va stabili existenta obiectului prin comparare cu
cea dea două variabilă, denumită generic “prag”, stabilită astfel încât orice valoare a primei variabile
care depăşeşte pragul să fie considerată obiect. În cadrul buclei while se aplică întâi funcţia edge ca
o variabilă de trei parametri ce reprezintă imaginea pe care se aplică funcţia, tipul de aproximare
folosit în determinarea conturului şi pragul returnat mai sus de aceeaşi funcţie. Această funcţie
ignoră toate pragurile mai mari decât cel setat, iar în cazul în care nu avem definit un prag, sau
valoarea pragului este nedeterminată, funcţia allege un prag automat Figura 16.
Mai departe am definit două elementa structurale “se90” şi “se0” de forma unei linii
verticale respective orizontale de trei elemente. Aceste două elemente reprezintă parametrii ai
funcţiei de dilatare a imaginii. Primul parametru al acestei funcţii este imaginea rezultată anterior
prin aplicarea funcţiei “edge”.Funcţia “imdilate” parcurge intraga imagine şi verifică valoarea
fiecărui pixel. În cazul pixelilor negrii (valoare 0) nu are loc nici o schimbare, deoarece aceşti pixeli
30
sunt caracteristici fundalului, însă în cazul întâlnirii unui pixel alb, acestuia îi va fi aplicat elementul
structural definit mai sus, rezultând o dilatare a conturului Figura 17.
În continuare am definit un nou element structural în formă de diamant plat denumit “seD”.
Al doilea parametru al funcţiei “strel”, care este un scalar numeric reprezintă distanţa dintre originea
elementului structural şi colţurile diamantului. Acest element structural este aplicat ca parametru în
cadrul funcţiei de erodare a conturului “imerode”. Această funcţie realizează erodarea, în urma
parcurgerii întregii imagini, aplicând elementul structural pentru fiecare pixel alb care nu este
încadrat de alţi pixeli albi, şi este aplicată de două ori.
În finalul buclei am realizat o eliminare a obiectelor ce au dimensiuni mai mici de 90 de
pixeli prin intermediul funcţiei “bwareaopen”, am implementat funcţia de incrementare a ariei şi am
31
decrementat fudgeFactor-ul, în aczul în care nu este îndeplinită condiţia de ieşire din bucla Figura
19.
32
% definite mai sus
% acest lucru se realizeaza pentru a inchide contururile
% obiectelor
for m = 1:r
for n = 1:c
if (BWfinal(m,n) == 1)
arie = arie + 1; % se calculeaza aria obiectelor din
% imagine (numarul de pixeli albi)
end
end
end
end
contur_img = BWfinal; % prima imagine care indeplineste conditia este
% returnata
De menţionat, ca acesta nu este un rezultat al muncii autorului în totalitate, ci a fost preluat din
Matlab Image Processing Toolbox, aducandu-i-se îmbunătăţiri pentru obţinerea rezultatelor optime.
33
Iniţial fotografiile au fost realizate pe fundal alb, însă datorită discrepanţei între nuanţă de gri
a umbrei şi fundalul alb s-a ajuns la folosirea unui prag de comparaţie de 90, mult prea mare. Astfel,
în special în cazul fructelor de culoare închisă pe suprafaţa cărora se regăsesc zone în care diferenţa
maximă dintre pixelii suprapuşi ai planelor RGB este sub valoarea pragului, aceştia vor fii
consideraţi umbre şi vor fi transformaţi în pixeli negri, urmând să deformeze substanţial imaginea
originală. În urma acestor incidente am ajuns la concluzia că folosirea unui fundal negru este cea
mai potrivită.
În continuare, este afişat codul în MATLAB, care implementează algoritmul de eliminare a
umbrelor:
end
end
end
34
clear_img = orig_img;
Imaginile din figurile de mai jos prezintă rezultatele, înainte şi după, rulării scriptului
MATLAB ce conţine codul de mai sus, realizate pe fundal negru cu prag 15:
Figura 20: Imaginea originală pe fundal negru (înainte de aplicarea algoritmului de eliminare
a umbrelor)
Figura 21: Imaginea fără umbre pe fundal negru (rezultată în urma aplicării algoritmului de
eliminare a umbrelor cu prag 15)
Imaginile din figurile de mai jos prezintă rezultatele, înainte şi după, rulării scriptului
MATLAB ce conţine codul de mai sus, realizate pe fundal alb cu prag 90:
35
Figura 22: Imaginea originală pe fundal alb (înaintea de aplicarea algoritmului de eliminare a
umbrelor)
Figura 23: Imaginea fără umbre pe fundal alb (rezultată în urma aplicării algoritmului de
eliminare a umbrelor cu prag 90)
36
Figura 24: Imaginea fără umbre pe fundal alb (rezultată în urma
aplicării algoritmului de eliminare a umbrelor cu prag 15)
Acest algoritm se aplică asupra imaginii rezultate în urma rulării algoritmului de eliminare a
umbrelor. Primul pas în realizarea acestui proces este este transformarea imaginii fără umbre în
imagine în nivele de gri, obiectiv atins prin folosirea funcţiei “rgb2gray”.
Ulterior prin intermediul funcţiei “bwboundaries” se determină limitele exterioare ale unui
obiect, precum şi contururile unor “găuri” conţinute în interiorul obiectului, returnându-se două
elemente folosite pe parcursul programului în cadrul a diverse funcţii. Prefixul “bw” implică faptul
că imaginea trebuie să fie neapărat binară în care pixelii cu valoare diferită de 0 reprezintă părţi
constituente ale obiectului, iar pixelii de valoare 0 (negri) reprezintă pixeli de fond. Primul element,
notat “B”, reprezintă o matrice de de n × 2 elemente, unde n reprezintă numărul de pixeli ce intră în
alcătuirea conturului, în B fiind localizat mai exact conturul obiectului din imagine, fiecare linie din
matricea amintită codificând de fapt coordonatele unui anumit pixel component al conturului.
Aceste coordinate sunt ordonate în sensul acelor de ceasornic. Al doilea argument de ieşire, notat
“L”, reprezintă o matrice etichetă. Sunt etichetate atât obiectele cât şi găurile conţinute. L este o
matrice bidimensională de valori întregi nenegative ce reprezintă o regiune contiguă din imagine.
Observăm că această funcţie este dependentă de doi parametrii: primul reprezintă imaginea de
intrare, pe care se aplică funcţia, iar cel deal doilea, care este un şir de caractere predefinit în Matlab,
şi anume “noholes”, grăbeşte operarea algoritmului, obligându-l să realizeze căutări numai pentru
contururile obiectelor, cele ale eventualelor găuri fiind eliminate.
Mai departe avem definită funcţia “label2rgb” care realizează conversia mătricii eticheta L,
obţinută mai sus, într-o imagine colorată RGB cu scopul de vizualizare a regiunilor etichetate.
Matricea etichetă L este văzută, de asemenea, ca prim parametru al acestei funcţii. Cel deal doilea
37
parametru, notat cu “MAP”, defineşte harta color care va fi folosită în cadrul imaginii RGB. Acesta
poate fi fie o matrice a hărţii color de n × 3 elemente, fie un şir de caractere care conţine numele
funcţiei hărţii color (de exemplu “jet”), ori o funcţie mâner a funcţiei hărţii color, care este folosită şi
în cazul nostrum, şi anume “@jet”. Dacă acest parametru nu este specificat este ales predefinit “jet”.
Al treilea parametru reprezintă culoarea fundalului, care dacă nu este specificat este luat negru din
oficiu. În continuarea programului sunt afişate rezultatele parţiale obţinute în urma rulării
algoritmului şi care sunt reţinute pentru a se afişa contururile corespunzătoare obiectelor Figura 25.
În bucla “for”, realizată în continuare, se introduce conturul peste imaginea reţinută anterior,
cu ajutorul funcţiei “plot” care are că parametrii coordonatele conturului conţinute în matricea
bidimensională B, culoarea de afişare a acestuia şi grosimea liniei de contur.
38
specifică celui de-al doilea parametru al funcţiei. Proprietăţile de care avem noi nevoie sunt cele
privitoare la arie şi la centrul de greutate, după cum se poate observa şi în secţiunea de cod ataşată.
Ulterior se face o parcurgere a contururilor, care se reţin în cadrul unei variabile denumită
generic “boundary”, în vederea calculării perimetrului conturului k. De asemenea, într-o variabilă
“area” se reţine din structura matricială “stats” valoarea corespunzătoare ariei obiectului k.
Perimetrul şi aria obiectului k se reţin în vederea calculării unei metrici ce reprezintă coeficientul de
rotunjime a obiectului k. Observăm că formula pentru calculul metrici este
metric (k ) = 4 ⋅ π ⋅ area (k ) / perimeter 2 , care în cazul unui cerc perfect returnează valoarea 1. în
cazul în care obiectul nu este perfect rotund perimetrul obiectului va creşte disproporţional cu aria,
iar rezultatul returnat va fi subunitar. Astfel, cu cât forma obiectului va fi mai îndepărtată de rotund
cu atât acest coeficient va fi mai apropiat de zero.
În final rezultatul numeric al metricii este afişat pe imagine, la coordonatele specificate în
cod, cu grosimea şi culoarea menţionată de asemenea în cod, iar în cazul mai multor obiecte se
returnează metrica cu valoarea cea mai mare Figura 3.1.4.c.
39
for k = 1:length(B) % fiecare contur gasit si retinut in matricea B
boundary = B{k}; % se afiseaza peste imaginea afisata anterior
plot(boundary(:,2), boundary(:,1), 'w', 'LineWidth', 2)
end
delta_sq = diff(boundary).^2;
perimeter = sum(sqrt(sum(delta_sq,2)));
% se calculeaza perimetrul conturului
text(boundary(1,2)-35,boundary(1,1)+13,metric_string,'Color','y',...
'FontSize',14,'FontWeight','bold'); % se afiseaza metrica obtinuta
end
Menţionez, ca acesta nu este un rezultat al muncii autorului în totalitate, ci a fost preluat din
Matlab Image Processing Toolbox, aducandu-i-se îmbunătăţiri pentru obţinerea rezultatelor optime.
Metoda aleasă pentru determinarea dimensiunii obiectelor fotografiate este una relativ
simplă. Imaginea pe care se lucrează eate imaginea rezultată în urma algoritmului de elimiare a
umbrelor. Iniţial intraga imagine este parcursă în vederea determinării ariei totale a acesteia, după
care se calculează aria obiectului conţinut în imagine. Imaginea rezultată în urma eliminării
umbrelor reprezintă obiectul fotografiat înconjurat de un fundal negru după cum se poate observa în
Figură xxx. Aria obiectului se determină prin adunarea tuturor pixelilor care au valoarea diferită de
0 (pixeli care nu sunt negri). Pentru a obţine o valoare finală cuprinsă în intervalul [0;1] suprafata
ocupată de fruct este împărţită la aria totală a imaginii. În acest interval valoarea 1 reprezintă
valoarea maximă, practic, imposibil de atins deoarece asta ar însemna că fructul ocupă întreaga
imagine.
40
Scriptul Matlab prezentat mai jos implementează algoritmul de calcul a dimensiunii
fructului:
arie = 0;
dim = r*c; % se calculeaza aria totala a imaginii
for m = 1:r
for n = 1:c
if (clear_img(m,n,1) ~= 0)
arie = arie + 1; % se calculeaza aria obiectelor din imagine
end
end
end
Mai jos sunt indicate rezultatele obţinute în urma rulării programului Matlab pentru
obiectele: Cireaşă, Lămâie respectiv Pepene:
Şi în cazul acestui algoritm imaginea care a fost luată în considerare pentru prelucrare este
cea obţinută în urma eliminării umbrelor din imaginea originală.
În vederea realizării lui am considerat o variabilă denumită generic “contor”, care în urma
parcurgerii întregii imagini se incrementează cu fiecare pixel, de culoare diferită de negru, întâlnit.
Ulterior, se realizează suma valorilor fiecărui pixel pe fiecare linie, obţinându-se o matrice
tridimensională (o dimensiune pentru fiecare din planurile R, G, B) cu o coloană şi r rânduri, unde r
reprezintă numărul de rânduri ale imaginii. La matricea astfel obţinută se realizează o sumă a
coloanei specifice fiecărui plan, obţinându-se în final trei valori ce indică luminozitatea tuturor
pixelilor din imagine pentru fiecare plan de culoare. După obţinerea acestor valori are loc o mediere
prin împărţirea lor cu valoarea finală a variabilei “contor”. În final realizăm o normalizare a
valorilor recent obţinute prin împărţirea lor cu valoarea numerică 255.
În acest moment am întâlnit o nouă problemă în ceea ce priveşte compatibilitatea dintre
valorile determinate în urma procesării imaginii cu algoritmii specifici şi sistemul decizional cu
logică fuzzy. Algoritmul de detecţie a culorii returnează trei valori distincte, câte una asociată
fiecărui plan, în timp ce intrarea corespunzătoare culorii în sistemul de sortare cu logică fuzzy poate
primii o singură valoare numerică pentru a o introduce în procesul de fuzzificare. Astfel, trebuie
căutată o soluţie pentru a obţine informaţia de nuanţă conţinută într-o singură variabilă numerică.
Soluţia găsită pentru a trece peste acest impediment a fost de a trece din planul RGB de
reprezentare a imaginii în planul HSV. Aparent problema nu este rezolvată deoarece la fel ca şi
planul RGB şi planul HSV încapsulează trei valori ale informaţiei de culoare. Totuşi, diferenţa
dintre cele două reprezentări este aceea că, spre deosebire de planul RGB, în care culoarea finală se
obţine prin combinarea celor trei plane cromatice, informaţiile de culoare conţinute în reprezentarea
41
HSV este următoarea: H-Hue (Nuanţa), S-Saturation (Saturaţie), V-Value (Valoare). Dintre aceste
trei valori, doar una singură prezintă interes pentru noi şi anume informaţia de nuanţă returnată de
variabila H. Astfel, pentru atingerea acestui deziderat am realizat conversia celor trei valori obţinute
din reprezentarea RGB în reprezentarea HSV, după care prima valoare returnată este preluată
separat de celalte două şi normalizată, rezultând astfel o singură valoare numerică compatibilă cu
variabilă de intrare Culoare a sistemului decisional.
Codul Matlab care realizează procesul descries mai sus este următorul:
for m = 1:r
for n = 1:c
if (~((img(m,n,1) == 0) && (img(m,n,2) == 0) && (img(m,n,3) == 0)))
contor = contor + 1; % daca pixelul nu are valoarea 0 in toate
end % planurile RGB contorul este incrementat
end
end
p = sum(img,2); % se face suma valorilor pixelilor pe fiecare linie
% obtinand o matrice tridimensionala avand o coloana
% r randuri si 3 planuri
Mai jos sunt indicate rezultatele obţinute în urma rulării programului Matlab pentru
obiectele: Cireaşă, Lămâie respectiv Pepene:
Acest algoritm implementează ultima etapă în derularea întregului process de sortare bazată
pe sisteme cu logică fuzzy, şi anume afişarea tipului obiectului şi a stării acestuia în urma rulării
42
tuturor algoritmilor premergători, precum şi a proceselor de fuzzificare, inferenţă şi defuzzificare
ulterioare algoritmilor menţionaţi.
Rezultatele finale ale întregului proces reprezintă returnarea a două valori numerice, una
reprezentând tipul fructului iar cealaltă starea acestuia, ambele valori fiind cuprinse în intervalele de
definire a universului discuţiei pentru ieşirile corespunzătoare: TipFruct definit pe intervalul
continuu [-0.1;8.1], respectiv StareFruct derulată dea lungul intervalului [-0.1;1.1].
În realizarea acestui script s-a luat în considerare faptul că fiecare din mulţimile fuzzy ale
variabilelor de ieşire poate să reprezinte un obiect sau starea acestuia, dacă valoarea final returnată
se află în intervalul definit între mijloacele intervalelor determinate de de mulţimea fuzzy
corespunzătoare obiectului respectiv şi mulţimile fuzzy corespunzătoare obiectelor învecinate.
Excepţie de la această regulă fac doar mulţimile fuzzy care sunt plasate la capetele de definire ale
universelor variabilelor de ieşire, şi anume, mulţimea Măr şi Pepene aparţinând ieşirii TipFruct, şi
ambele mulţimi componente ale variabilei de intrare, StareFruct, Necopt respectiv Copt.
Programul în limbaj Matlab care returnează aceste valori finale este ilustrat în cele ce
urmează:
slf=readfis('SLF.fis');
ValFruct = evalfis(val_fr, slf);
43
if -0.1 < ValFruct(1,2) & ValFruct(1,2) <= 0.5
StareFruct = ' necopt';
else
StareFruct = ' copt';
end
Mai jos sunt indicate rezultatele obţinute în urma rulării programului Matlab de returnare a
obiectelor şi a stării acestora pentru cireaşă coaptă, lămâie necoaptă şi pepene copt:
Cireaşă coaptă
Lămâie necoaptă
Pepene copt
Funcţia principală reprezintă secţiunea de cod în care sunt apelate în ordine toate funcţiile
enumerate mai sus, fiecare realizând algoritmul corespunzător ei. Aceasta este prezentată în
rândurile ce urmează:
clear all;
close all;
clc;
addpath(genpath(pwd));
%% Preluare imagine fruct
img = achizitie(); % se preia imaginea
figure(1);
imshow(img);
title('Imaginea originala');
%% Detectie contur
contur_img = contur(img); % detectia de contur a fructului
% conturul poate fii eronat din cauza umbrelor
44
% fructului
figure(2);
imshow(clear_img);
title('Imaginea fara umbre');
%% Determinare forma
aspect = forma(clear_img); % se determina o valoare intre 0 si 1
% reprezentand cat de rotund este fructul
% pentru val 1 fructul este un cerc perfect
%% Determinare culoare
culoare = color_detect(clear_img); % algoritmul de detectie al culorii
%% Recunostere fruct
fruct = rec_fruct(val_fr);
disp(fruct)
Obiectivul proiectului este proiectarea unui sistem decizional bazat pe logică fuzzy, care să
dea ca ieşirii tipul fructului şi starea acestuia.
45
Am început proiectarea de la un model fuzzy cu trei intrări (Aspect, Dimensiune, Culoare) şi
două ieşiri (TipFruct şi StareFruct).
Modelul fuzzy proiectat în Matlab arată ca şi în figură de mai jos:
Cele trei dreptunghiuri de culoare galbenă reprezintă cele trei intrări ale sistemului cu logică
fuzzy, respective aspectul, dimensiunea şi culoarea. La nivelul acestor trei blocuri are loc procesul
de fuzzificare.
Dreptunghiul de culoare gri deschis reprezintă procesul de inferenţă, iar cele două
dreptunghiuri de culoare turqouis reprezintă ieşirile blocului de fuzzificare (la nivelul acestor
dreptunghiuri are loc procesul de defuzzificare).
Editarea regulior se face în dreptunghiul gri deschis (de inferenţă), în fereastra Rule Editor:
3.2.1. Intrări
3.2.1.1. Definirea mulţimilor fuzzy pentru variabila de intrare aspect
Universul discuţiei variabilei de intrare aspect, notată Aspect, se defineşte pe intervalul [0;1].
Pentru definirea mulţimilor fuzzy pentru variabila de intrare Aspect se foloseşte o acoperire a
universului variabilei de intrare, prin patru mulţimi trapezoidale asimetrice (Alungit, Neregulat,
Oval, Rotund) astfel încât cele patru mulţimi să formeze o partiţie fuzzy. Intervalul de definire a
46
universului discuţiei şi a mulţimilor fuzzy constituente a fost determinat pe baza rezultatelor
experimentale obţinute în urma rulării algoritmilor Matlab de extragere a caracteristicilor obiectelor
fotografiate. Iniţial am ales doar trei mulţimi fuzzy pentru această intrare, însă pentru a obţine
rezultate mai precise fără o complicaţie majoră a calculelor am ales patru mulţimi fuzzy reprezentate
în figură de mai jos:
Figura 30: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Aspect
47
Figura 31: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Dimensiune
48
Figura 32: Mulţimile fuzzy initiale peste universul discuţiei variabilei de intrare Culoare
Figura 33: Mulţimile fuzzy finale peste universul discuţiei variabilei de intrare Culoare
3.2.2. Ieşirile
Universul discuţiei variabilei de ieşire care indică tipul fructului, notată TipFruct, se definiste
plecând de la observaţia că sistemul fuzzy proiectat este de tip decizional, iar mărimile fuzzy
implicate nu reprezintă un interval de variaţie a mărimii de intrare, intervalele de definiţie neavând
nici un punct de intersectare. Ca urmare universul discuţiei pentru TipFruct este [-0.1;8.1].
Pentru definirea mulţimilor fuzzy pentru ieşirea TipFruct , s-a considerat un eşantion de nouă
mulţimi, fiecare asociată unui anumit tip de fruct (Măr, Piersică, Caisă, Lămâie, Portocală, Cireaşă,
Avocado, Banană, Pepene) după cum se observă în Figura 34. Intervalul de definire a mulţimilor
fuzzy sunt centrate în numerele întregi cuprinse în intervalul de definire a universului discuţiei, cu o
lăţime la stânga şi la dreapta, standard, de 0.1. Cele nouă mulţimi sunt mulţimi fuzzy triunghiulare,
definite astfel încât nu formează o partiţie fuzzy.
49
Figura 34: Mulţimile fuzzy peste universul discuţiei variabilei de iesire TipFruct
Figura 35: Mulţimile fuzzy peste universul discuţiei variabilei de iesire StareFruct
După ce am stabilit structura celor trei variabile de intrare şi a celor două variabile de ieşire
este nevoie de conceperea unor reguli de baza după care va funcţiona sistemul de sortare. În funcţie
de valorile preluate de intrările acestui sistem, valori rezultate prin prelucrarea imaginilor cu
algoritmii prezentaţi anterior, vom obţine la ieşirile sistemului decizional un anumit tip de fruct aflat
într-o anumită stare. Regulile de tip “If…then…/Dacă…atunci…” ale sistemului cu logică fuzzy reflectă
50
capacitatea de decizie a sistemului. Regulile sunt afirmaţii calitative deduse de către proiectantul sistemului
de control fuzzy din datele şi experimentele realizate în procesul de selecţie a imaginilor cu algoritmii
enunţaţi. Astfel, am creat o baza ce conţine 18 reguli enunţate mai jos:
• 1. If (Aspect is Neregulat) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct
is Avocado)(StareFruct is Copt)(1)
• 2. If (Aspect is Neregulat) and (Dimensiune is Mic) and (Culoare is Verde) then (TipFruct is
Avocado)(StareFruct is Necopt) (1)
• 3. If (Aspect is Rotund) and (Dimensiune is FoarteMic) and (Culoare is Rosu) then (TipFruct
is Cireasa)(StareFruct is Copt) (1)
• 5. If (Aspect is Alungit) and (Dimensiune is Mare) and (Culoare is Galben) then (TipFruct is
Banana)(StareFruct is Copt) (1)
• 6. If (Aspect is Alungit) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct is
Banana)(StareFruct is Necopt) (1)
• 8. If (Aspect is Rotund) and (Dimensiune is Mic) and (Culoare is Verde) then (TipFruct is
Caisa)(StareFruct is Necopt) (1)
• 9. If (Aspect is Oval) and (Dimensiune is Mare) and (Culoare is Galben) then (TipFruct is
Lamaie)(StareFruct is Copt) (1)
• 10. If (Aspect is Oval) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct is
Lamaie)(StareFruct is Necopt) (1)
• 11. If (Aspect is Rotund) and (Dimensiune is FoarteMare) and (Culoare is Portocaliu) then
(TipFruct is Pepene)(StareFruct is Copt) (1)
• 12. If (Aspect is Rotund) and (Dimensiune is Mare) and (Culoare is Verde) then (TipFruct is
Pepene)(StareFruct is Necopt) (1)
• 13. If (Aspect is Rotund) and (Dimensiune is Mare) and (Culoare is Rosu) then (TipFruct is
Mar)(StareFruct is Copt) (1)
• 14. If (Aspect is Rotund) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct
is Mar)(StareFruct is Necopt) (1)
• 15. If (Aspect is Rotund) and (Dimensiune is Mediu) and (Culoare is Rosu) then (TipFruct is
Piersica)(StareFruct is Copt) (1)
51
• 16. If (Aspect is Rotund) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct
is Piersica)(StareFruct is Necopt) (1)
• 17. If (Aspect is Rotund) and (Dimensiune is Mare) and (Culoare is Portocaliu) then
(TipFruct is Portocala)(StareFruct is Copt) (1)
• 18. If (Aspect is Rotund) and (Dimensiune is Mediu) and (Culoare is Verde) then (TipFruct
is Portocala)(StareFruct is Necopt) (1)
Pentru a înţelege mai bine modul în care funcţionează sistemul de srtare cu logică fuzzy
proiectat anterior voi prezenta în cele ce urmează un exemplu cu modul de activare a regulilor.
Exemplul din fereastră de mai jos se referă la cazul în care aspectul este cuprins în intervalul
[0.8375;0.88], dimensiunea se află în intervalul [0.042;0.08], iar culoarea este definite pe
intervalul[31;45]. Aspectul are valoarea 0,87239, dimensiunea are valoarea 0,067996 şi culoarea are
valoarea 35,4118. Pentru valoarea 0,87239 a aspectului, regulile ce se activează sunt: 9 şi 10. fiecare
din aceste reguli se activează cu un anumit grad,în cazul celor două gradul de activare fiind similar
de 100%.
Pentru cazul dimensiunii, regulile ce se pot activa sunt: 1, 5, 6, 7, 9, 10, 12, 13, 14, 15, 16,
17, 18. La fel ca în cazul aspectului , fiecare din aceste reguli se activează într-o anumită proporţie:
regulile 1, 6, 7, 10, 14, 15, 16, 18 se activează în proporţie de 100% şi regulile 5, 9, 12, 13, 17 în
proporţie de aproximativ 25%.
Pentru culoare, regulile ce se activează sunt: 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, toate activate în
proporţie de 100%.
Combinând cele trei seturi de reguli ce se pot activa obţinem setul final de o singură regulă
în acest caz, şi anume regula 10.
52
Figura 36: Fereastra Rule Viewer
Valoarea de 0, 87239 din variabila de intrare Aspect este corespunzătoare mulţimii fuzzy
Oval, cea de 0,067996, aparţinând variabilei de intrare Dimensiune, este corespunzătoare mulţimii
fuzzy Mediu, iar valoarea de 35,4118 din variabila de intrare Culoare este asignată mulţimii fuzzy
Verde.
Enunţul regulii 10 este următorul: Dacă Aspect este Oval Şi Dimensiune este Mediu Şi
Culoare este Verde Atunci TipFruct este Lămâie Starefruct este Necopt.
În urma aplicării operaţiei de defuzzificare observăm că avem returnate la ieşirile sistemului
decizional două valori numerice: prima valoare este atribuită ieşirii care indică tipul fructului
(TipFruct), iar cea dea doua valoare este atribuită stării în care se află acesta (StareFruct). Cele două
valori returnate în cazul nostru sunt: 3,02 pentru tipul fructului şi -0,004 pentru starea sa. După cum
am amintit anterior în cadrul definiri variabilelor de ieşire, mulţimile fuzzy corespunzătoare fiecărei
variabile de ieşire sunt reprezentate în jurul unor valori întregi cu o lăţime a intervalului la dreapta şi
la stânga de 0,1. Astfel, prin asocierea valorilor obţinute cu fructul, respectiv cu starea
corespunzătoare rezultatele finale sunt: tipul fructului – lămâie, iar starea sa – necopt, în
concordanţă cu regula numărul 10, de aici rezultând ca sistemul de sortare este corect funcţional.
53
3.2.5. Rezultatele proiectării sistemului de sortare
54
3.2.6. Defuzzificarea
Sistemul de sortare cu logică fuzzy realizat în această aplicaţie este de tip Mamdani, iar
metoda de defuzzificare aleasă este “mom” adică media maximelor.
Sistemele Mamdani diferă faţă de cele Takagi-Sugeno prin faptul că în cazul celor dintâi
ieşirile reprezintă o distribuţie de mulţimi fuzzy, în timp ce în cazul celor secundare intrarea este
transformată într-o singură mulţime fuzzy a cărei suport este un singur punct din universal discuţiei
(valoare tranşantă), cu grad de apartenenţa 1.
Fiecare regulă are un anumit grad de activare în urma valorilor preluate, rezultate din
procesarea algoritmilor corespunzători, de către sistemul de sortare cu logică nuanţată. Operaţia
fuzzy aplicată asupra intrărilor este “şi”, deoarece ieşirea este influenţată ca un cumul al celor trei
intrări, iar metoda de implicaţie folosită este “min”, care va trunchia gradul de activare al intrărilor
supuse la operaţia fuzzy la valoarea minimă. După realizarea implicaţiei are loc agregarea
rezultatelor care este de tip “max” şi care va cumula maximele fiecărei ieşiri în vederea aplicării
metodei de defuzzificare.
Metoda de defuzificare aleasă este “mom” sau media maximelor. Am ales această metodă
datorită faptului că sistemul fuzzy antrenat nu este un sistem folosit pentru control ci este un sistem
decizional, care returnează valori tranşante. Aceasta presupune reţinerea celui mai mic maxim în
valoare absolută (SOM), a celui mai mare maxim în valoare absolută (LOM) şi realizarea mediei
acestora (MOM). Deoarece, în cazul nostru, probabilitatea de a avea un platou este foarte redusă,
deoarece mulţimile fuzzy de ieşire sunt triunghiuri destul de înguste, cele trei valori s-ar putea să
coincidă sau dacă nu să fie foarte apropiate.
În urma stabilirii valorii medii maxime, sistemul decizional va considera mulţimea fuzzy
corespunzătoare valorii respective, ca mulţime de ieşire corectă, iar algoritmul Matlab realizat
pentru returnarea rezultatelor finale va prelua valoarea corespunzătoare ieşirii în vederea afişării ei.
55
Concluzii
56
5. Bibliografie
[1] Tehnici fuzzy în proiectarea şi modelarea circuitelor analogice – Gabriel Oltean, Emilia Sipos –
Ed. U.T. Press, Cluj-Napoca
[2] An Introduction to fuzzy set theory and fuzzy logic – Chander Mohan
[3] Image Processing Toolbox - Matlab
[4] Image Acquisition Toolbox - Matlab
[5] Toward a definition of Fuzzy Processes – L. Luca, I. Despi
[6] Spaţii de procese fuzzy – L. Luca, Ed. Mirton, Timişoara, 2003
[7] www.mathworks.com/products/fuzzylogic/
57