Sunteți pe pagina 1din 57

UNIVERSITATEA TEHNICĂ DIN CLUJ-NAPOCA

FACULTATEA DE ELECTRONICĂ, TELECOMUNICAŢII ŞI


TEHNOLOGIA INFORMAŢIEI
Specializarea: Electronică Aplicată

Sistem de sortare bazat pe logică fuzzy

Proiect de diplomă

PREŞEDINTE COMISIE, DECAN,


Prof. dr. ing. Marina ŢOPA Prof. dr. ing. Marina ŢOPA

CONDUCATOR, ABSOLVENT,
Prof. dr. ing. Gabriel OLTEAN Teodor Florin CIORTEA
2010

Titlul temei: Sistem de sortare bazat pe logică fuzzy

Enunţul proiectului de diplomă:

Sistem de sortare bazat pe logică fuzzy


Tipul proiectului: dezvoltare şi implementare de software
Cerinţe impuse: clasificarea unor obiecte cu caracteristici asemănătoare, preluarea
imaginii unui obiect, salvarea lui în format .jpg, preluarea imaginii în Matlab,
extragerea caracteristicilor obiectului (culoare, formă, dimensiune) utilizând tehnici
fuzzy, clasificarea obiectului pe baza caracteristicilor extrase utilizând SLF/ algoritmi
de clasificare fuzzy/ reţea neuronală.

Locul de execuţie: Laboratorul de Sisteme cu Logică Nuanţată, sala 329, Str: George
Bariţiu 26-28

Data emiterii temei: 20 octombrie 2009

Termen de predare: 24 iunie 2010

ŞEF CATEDRĂ, ABSOLVENT,


Prof. dr. ing. Lelia FEŞTILĂ Teodor Florin CIORTEA

CONDUCĂTOR,
Prof. dr. ing. Gabriel OLTEAN

2
Declaraţia autorului

Subsemnatul declar prin prezenţa că ideile, partea de proiectare şi experimentală, rezultatele,


analizele şi concluziile cuprinse în această lucrare constituie efortul meu propriu, mai puţin acele
elemente care nu-mi aparţin, pe care le indic şi le recunosc că 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 către mine.

În calitate de autor, cedez toate drepturile de utilizare şi modificare a lucrării de diplomă


către Universitatea Tehnică din Cluj-Napoca.

Cluj-Napoca, 24 iunie 2010

ABSOLVENT,
Teodor Florin CIORTEA

3
1. Numele şi prenumele studentului: Teodor Florin CIORTEA
2. Numele şi prenumele conducătorului: Prof. dr. ing. Gabriel OLTEAN

SINTEZA PROIECTULUI DE DIPLOMĂ

Enunţul Temei: Sistem de sortare bazat pe logică fuzzy

Sistemele de sortare cu logică fuzzy reprezintă o soluţie modernă în realizarea sistemelor


decizionale, bazate pe diverse trăsături asemănătoare ale obiectelor. În această lucrare s-a realizat
proiectarea şi dezvoltarea unui astfel de sistem de clasificare, bazat pe extragerea unor caracteristici
şi apoi utilizarea acestora pentru realizarea selecţiei (luarea deciziei). Intrarea acestui sistem constă
în imagini color ale obiectelor de clasificat.
Aplicaţia beneficiază de o implementare pe două nivele. Primul nivel eate reprezentat de
algoritmii de extragere a celor trei caracteristici (aspect fizic, culoare, mărime), realizaţi în mediul
de dezvoltare integrat (IDE) Matlab, iar cel de-al doilea nivel constă în proiectarea unui sistem de
decizie cu logică fuzzy, de tip Mamdani, cu trei intrări, corespunzătoare trăsăturilor obiectelor şi
două ieşiri, ce semnifică tipul respectiv starea obiectelor. Ulterior, este realizată legatura între
sistemul de sortare şi parametrii de intrare rezultaţi în urma prelucrării imaginilor cu algoritmii
corespunzători. Deoarece, sistemul în discuţie este unul decizional şi nu de control am utilizat ca
metodă de defuzzificare metoda mediei maximelor (MOM). Valorile returnate la ieşire în urma
defuzzificarii, sunt corelate cu variabilele lingvistice corespunzătoare în vederea afişării rezultatelor
finale, rezultate care dovedesc corectitudinea proiectării şi implementării întregului proces.

ABSTRACT

Paper title: Sorting system based on fuzzy logic

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

Name: Teodor Florin Ciortea


th
Date of birth: 14 of May, 1987

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:

English Conversation: Well


Writing: Well
Reading: Well
French Conversation: Acceptable
Writing: Acceptable
Reading: Acceptable

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ă

- după o consultare prealabilă cu subsemnatul

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

Figura 1: Schemă logică pentru metodologia propusă

Punctul de plecare în implementarea unui astfel de sistem de clasificare este reprezentat de


specificaţiile sistemului. Figură de mai sus reprezintă schemă logică a metodologiei propuse.
După ce au fost făcute specificaţiile sistemului de sortare urmează proiectarea unui model
decizional cu logică fuzzy în Matlab FIS Editor. Acest model este analizat, testat şi ajustat până
când rezultatele experimentale corespund cu performanţele cerute.

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.

2.2.1. Mulţimile fuzzy

Conceptul de mulţime fuzzy, introdus de către Zadeh, a apărut ca o urmare frească a


imposibilităţii de a modela un sistem indenit (din engl.: ill-defned) cu ajutorul unor instrumente
matematice precise, cum ar fi cele ale teoriei probabilistice.
Fie X o colecţie de obiecte. Mulţimea fuzzy A definită pe mulţimea X este o mulţime de
perechi ordonate:

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

unde prin integrare se înţelege totalitatea punctelor µ A ( x) / x .


Pentru o mai bună înţelegere a mulţimilor fuzzy definim cinci concepte:
1. Variabilă lingvistică x = : o proprietate, un atribut al obiectului (obiectelor) în discuţie

2. Valoare lingvistică A = : un adverb, adjectiv asociatvariabilei lingvistice, care dă şi numele


mulţimii fuzzy asociate

3. Universul discuţiei X = : o mulţime clasică, tranşantă, pe care se definesc mulţimile fuzzy

4. Gradul de apartenenţa µ = : arată masura în care un element aparţine unei mulţimi fuzzy, µ ∈
[0;1]

5. Funcţia de apartenenţa µ A ∈ : asociază fiecărui element x gradul de apartenenţa la mulţimea fuzzy


A:

µ A ( x) : X → [0;1]

Astfel, mulţimea fuzzy A este complet determinată de mulţimea perechilor ordonate:

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

2.2.2. Variabile lingvistice

În timp ce variabilele matematice i-au de obicei valori numerice, în aplicaţiile cu logică


fuzzy, variabilele lingvistice nenumerice sunt adesea folosite pentru a facilita exprimarea regulilor şi
a faptelor.
O variabilă lingvistică precum “vârsta” poate lua o valoare precum “tânăr” sau antonimul
acestuia “bătrân”. Oricum, marea utilitate a variabilelor lingvistice este aceea că pot fi modificate
prin intermediul pragurilor lingvistice aplicate termenilor primari. De asemenea, pragurile
lingvistice pot fi asociate unor funcţii certe.

2.2.3. Grade de adevăr

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.

2.2.4. Aplicarea valorilor de adevăr

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].

În această imagine, înţelesul expresiilor RECE, CALD, FIERBINTE este reprezentat de


funcţii care acoperă scara de temperatura. Un punct conţinut în acest interval are trei “valori de
adevăr”- una pentru fiecare din aceste trei funcţii. Linia verticală din imagine reprezintă o anumită
temperature pe care cele trei săgeţi (valori de adevăr) de ecartament o indică. Din moment ce
sageata roşie pointeaza spre zero, acesta temperatură poate fi interpretată ca fiind “nu fierbinte”.
Sageata portocalie (care indică spre 0,2) descrie această temperatură ca fiind “uşor caldă”, în timp ce
sageata albastră (care pointeaza la 0,8) descrie temperatura ca fiind “destul de rece”.

2.2.5. Raţionament fuzzy

Raţionamentul fuzzy (sau raţionamentul aproximativ) este analogul logicii predicatelor


pentru raţionamentul cu propoziţii precise şi este, aşadar, o extensie a logicii propoziţiilor clasice.
Raţionamentul fuzzy foloseşte propoziţii fuzzy care sunt afirmaţii ce pot fi adevărate în anumite
grade cuprinse în intervalul [0; 1]. Aceste propoziţii sunt exprimate folosind limbajul natural. Un
model de propoziţie fuzzy este:
“ x este A ”
unde x este o variabilă lingvistică iar A este o valoare lingvistică a variabilei x . Înţelesul acestei
propoziţii este determinat de mulţimea fuzzy A definită pe universul discuţiei variabilei x .
Regulile fuzzy sunt propoziţii condiţionale de tipul DACĂ-ATUNCI care folosesc variabile şi valori
lingvistice fuzzy:
“ Daca x este A atunci y este B ”
unde A şi B sunt valori lingvistice definite prin mulţimi fuzzy pentru variabilele lingvistice x ,
respectiv y.
Partea DACĂ a regulii ( x este A ) se numeşte premisă sau antecedent, pe când partea
ATUNCI ( y este B ) se numeşte concluzie sau consecvent.
Interpretarea unei reguli fuzzy are loc în două etape: mai întâi se evaluează premisa iar apoi
se aplică acest rezultat concluziei. Dacă premisa este adevărată într-un anumit grad, atunci concluzia
este adevărată în acelaşi grad.
În logica Booleană principalele instrumente de raţionament sunt tautologiile, cum sunt
modus ponens şi modus tolens. În logica fuzzy este folosit acelaşi principiu, dar în locul
propoziţiilor tranşante sunt folosite propoziţii şi reguli fuzzy. Cea mai folosită tautologie în
raţionamentul fuzzy este modus ponens generalizat (MPG):

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]

Figura 4: Inferenţa compoziţională

2.2.6. Proprietăţile mulţimilor fuzzy

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 ) ≥ α }

sunt convexe pentru orice α ∈ [0;1].

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

Folosind această definiţie, o mulţime fuzzy poate fi considerată o reuniune de valori


singulare.

2.2.7. Sisteme cu logică fuzzy

Un sistem cu logică fuzzy (SLF) permite modelarea şi implementarea funcţionării oricărui


proces prin descrierea relaţiilor intrare-ieşire folosind variabile şi valori lingvistice şi reguli fuzzy
DACĂ-ATUNCI. Valorile numerice tranşante ale variabilelor de ieşire rezultă prin aplicarea unor
operaţii: fuzzificare, inferenţă fuzzy, defuzzificare, asupra valorilor numerice ale variabilelor de
intrare.
După Brubaker dezvoltarea unui SLF este justificată pentru sistemele a căror funcţionare
este prea complexă pentru a putea fi definită adecvat prin tehnici tradiţionale:

• sisteme prea complexe pentru a fi modelate precis;


• sisteme cu funcţionare mediu spre puternic neliniară;
• sisteme ce prezintă anumite incertitudini fie în intrări fie în funcţionare.

Î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 Baza de Mulţimi


al

fuzzy de reguli fuzzy fuzzy de


intrare (A) ieşire (B)

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 structura SLF sunt cuprinse modulele:


• Fuzzificare =: interfaţa ce transformă valorile tranşante ale variabilelor de intrare ( x *) în
mulţimi fuzzy de tip singleton ( A *);
• Baza de cunoştinţe =: furnizează modulului Inferenţă informaţiile necesare:
- mulţimile fuzzy pentru variabilele de intrare ( A );
- mulţimile fuzzy pentru variabilele de ieşire ( B );
- baza de reguli fuzzy.
• Inferenţă =: blocul care determină valorile fuzzy ale variabilelor de ieşire ( B *) folosind
inferenţa fuzzy;
• Defuzzificare =: interfaţa ce transformă valorile fuzzy ale variabilelor de ieşire în valori
tranşante ( y *).

2.2.8. Sisteme cu locica fuzzy Takagi-Sugeno

Î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

2.2.9. Sistemele cu logică fuzzy Mamdani

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

Figura 8: Interpretarea diagramei fuzzy de inferenţa de tip Mamdani

2.3. Mediul de programare MATLAB

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.

2.3.1. Image Acquizition Toolbox

Image Acquizition Toolbox permite achiziţia videoclipurilor şi imaginilor direct în


MATLAB şi Simulink de la unităţi hardware compatibile PC. Hardware-ul poate fi detectat automat
şi configurat în conformitate cu cerinţele problemei, previzualizând achiziţia, după care are loc
achiziţia clipurilor video şi imaginilor. Având suport pentru furnizori multiplii de hardware, poate
folosi un domeniu larg de dispozitive de imagistică, de la camere web comune sau acaparatori
industriali de frame-uri până la camere ştiinţifice performanţe care confruntă iluminatul slab, viteză
ridicată, precum şi alte provocări.[4]

2.3.2. Image Processing Toolbox

Softul Image Processing Toolbox oferă un set comprehensiv de algoritmi-referinţă standard


şi unelte grafice pentru procesarea, analiza, vizualizarea şi dezvoltarea imaginilor. Acesta oferă
capacitatea de a restaura imagini afectate de zgomot sau degradate, îmbunătăţirea imaginilor pentru
creşterea inteligibitatii, extragerea de caracteristici, analizarea formelor şi texturilor şi înregistrarea a
două imagini. Cele mai multe funcţii ale toolboxurilor sunt scrise în limbaj MATLAB deschis,
oferind abilitatea inspectării algoritmilor, modificării codului sursă, şi creării propriilor funcţii
client.
Image Processing Toolbox suportă un set divers de tipuri de imagini, inclusive cu gama
dinamică ridicată, rezoluţii de gigapixeli sau imagini tomografice. Uneltele dinamice permit
explorarea unei imagini, examinarea unei regiuni de pixeli, ajustarea contrastului, crearea de
contururi sau histograme şi manipularea regiunilor de interes. De asemenea, imaginile suportate sunt
generate de o gamă largă de dispzitive, incluzând camere digitale, sateliţi sau senzori de aer,
dispozitive de imagistică medicală, microscoape, telescoape şi alte dispozitive stintifice. Aceste
imagini pot fi vizualizate, analizate şi procesate în mai multe tipuri de date, incluzând puncte
flotante cu precizie singulară şi duală, şi întregi cu semn sau fără semn pe 8, 16 şi 32 de biţi.

Î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.

Adiţional funcţiilor de afişaj, toolboxul dezvoltă o gamă de unelte interactive pentru


explorarea imaginilor. Se pot obţine informaţiile de imagine, mărirea şi conturarea acesteia precum
şi examinarea în detaliu a unei regiuni de pixeli. De asemenea, se poate manipula interactiv regiuni
de interes precum punctele, liniile, pologoanele, elipsele şi formele neregulate sau se pot ajusta
contrastele ori masura distanţele.

2.3.4. Procesarea şi postprocesarea imaginilor

Acest toolbox oferă algoritmi referinta-standard pentru procesarea şi postprocesarea


cerinţelor pentru rezolvarea frecvenţelor probleme de sistem, precum zgomotul, intervalul dinamic
redus, optica defocalizată şi diferenţa între reprezentarea diferită a intrării respectiv ieşirii unui
dispoziv.

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.

Algorimii de segmentare a imaginilor determină regiunile de limitare dintr-o imagine. Există


diverse abordări ale segmentării imaginilor, incluzând determinarea automată a unui prag, metode
bazate pe contur, şi metode bazate pe morfologie precum transformarea cotiturilor, utillizata des
pentru segmentarea obiectelor focalizate.[3]

2.3.5. Proiectarea şi simularea sistemelor fuzzy în MATLAB cu Fuzzy


Logic Toolbox
Fuzzy Logic Toolbox extinde mediul tehnic de calcul cu instrumente pentru proiectarea
sistemelor bazate pe logică fuzzy. Interfaţa grafică prezintă paşii de urmat în în proiectarea
sistemelor fuzzy. Sunt puse la dispoziţie funcţii pentru numeroase metode cu logică fuzzy comune,
inclusiv gruparea fuzzy ori învăţarea neurofuzzy adaptivă.

Toolboxul permite modelarea comportamentală a sistemelor logice complexe folosind reguli


logice simple, iar apoi implementarea acestor reguli într-un sistem de inferenţă fuzzy. Acest toolbox
poate fi folosit ca un motor de inferenţă de sine stătător. Alternativ, se pot folosi blocuri de inferenţă
fuzzy în Simulink, iar simularea sistemului fuzzy se face folosind un model comprehensiv al
întregului sistem dinamic.

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.

2.3.7. Construirea unui sistem de inferenţă 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:

• FIS Editor - afişează informaţii generale despre sistemul de inferenţă fuzzy

Figura 9: Editorul FIS

• Membership Function Editor (Editorul Funcţiilor Membre) - permite afişarea şi editarea


funcţiilor membre asociate variabilelor de intrare şi de ieşire a fişierului .FIS

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ă.

• Rule Viewer (Afişarea Regulilor) – permite observarea detaliată a comportamentului


unui fişier .FIS pentru a diagnostica dinamica unor reguli specifice său studia efectul
modificării variabilelor de intrare.

• Surface Viewer (Afişarea Sprafetelor) – generează o suprafaţă tridimensională a doua


variabile de intrare şi o ieşire a unui .FIS

Figura 11: Afişarea suprafeţelor


25
2.3.8. Modelarea utilizând logică fuzzy

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

Operaţia de asignare a unei valori reale corespunzătoare unei funcţii de apartenenţa se


numeşte defuzzificare, fiind necesară în numeroase aplicaţii în care rezultatele sunt fuzzy.
În esenţă, defuzzificarea reprezintă procesul de transformare a unei mărimi fuzzy într-o mărime
crisp. Ieşirea unui proces (sistem) fuzzy poate fi - din punct de vedere logic - reuniunea a două sau
mai multe funcţii de apartenenţa fuzzy, definite pe universul de discurs al variabilei de ieşire. De
exemplu, putem presupune că ieşirea fuzzy a unui sistem este alcătuită din două părţi: prima parte de
formă trapezoidală A1 şi a doua - de formă triunghiulară A2 . În general, ieşirea fuzzy A a unui
process poate implică mai multe funcţii de apartenenţa fuzzy de diferite forme; în acest caz
k
A = U Ai . Corespunzător convenţiei adoptateexista mai multe metode de defuzzificare, alegerea
i =1
metodei în aplicaţii bazându-se pe criterii care ţin de aprecierea rezultatelor obţinute în fiecare
aplicaţie dată.

a) Metoda maximului funcţiei de apartenenţa. Această metodă furnizează ca rezultat al


defuzzificarii, valoarea crisp x∗ , pentru care ∀x ∈ X µc ( x ) ≥ µc ( x) , ∀x ∈ X (Figura 12). Dacă

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

şi permite calculul valorii x∗ (Figura 13) conform relaţiei: f ( µ ( x )) =


−1 ∫ µc ( x) ⋅ xdx .
∫ µc ( x)dx

Figura 13: Metoda centrului de masă

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

de apartenenţa în punctele de maxim: f ( µ ( x )) =


−1 ∑ µC ( x ) ⋅ x .
∑ µc ( x )

Figura 14: Metoda mediei ponderate

a+b
d) Metoda mediei maximelor presupune calculul lui x∗ (Figura 15) unde: f ( µ ( x )) =
−1

Figura 15: Metoda mediei maximelor

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.

3.1. Extragerea caracteristicilor obiectelor

În vederea extragerii caracteristicilor obiectelor studiate trebuie avut în considerare că în


cazul fiecărui obiect, principalul impediment în atingerea scopului dorit a fost reprezentat de umbre
care, în lipsa unui algoritm eficient de eliminare a umbrelor influenţează dramatic rezultatele finale,
depărtându-le de realitate.

3.1.1. Achiziţia imaginilor

Î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.

Figura 16: Rezultatul obţinut în urma rulării funcţiei “edge”

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.

Figura 17: Rezultatul obţinut în urma rulării funcţiei “imdilate”

După terminarea procesului de dilatare a imaginii, urmează cel de umplere a golurilor,


realizat prin utilizarea funcţiei “imfill”. Această funcţie are definiţi doi parametrii, şi anume: primul
reprezintă imaginea de intrare, mai precis imaginea dilatată, iar cel deal doilea parametru
notat”holes” este unul predefinit în Matlab şi reprezintă un set de pixeli de fundal care nu pot fi
atinşi prin umplarea fundalului cuprins în conturul imaginii.

Figura 18: Rezultatul obţinut în urma rulării funcţiei “imfill”

Î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.

Figura 19: Rezultatul final al aplicarii algoritmului

function [contur_img] = contur(img)

gray_img = rgb2gray(img); % se transforma in tonuri de gri imaginea


% originala pentru a apela functia "edge"
[junk threshold] = edge(gray_img, 'roberts');%returneaza pragul folosit
% apoi in detectia
% conturului

fudgeFactor = 2; % factor folosit pentru o detectie cat mai precisa


% a contururilor, acesta influenteaza dimensiunea
% obiectelor conturate. Cu cat acesta este mai mare cu
% atat numarul obiectelor conturate va fi mai mare
arie = 0; % variabila folosita in stabilirea existentei
% obiectului
[r,c,d] = size(gray_img); % returneaza dimensiunile imaginii:r-randuri
% c-coloane
% d-adancime
prag = (r*c)/5; % se stabileste un prag peste care interiorul
% conturului este considerat obiect

while arie<prag % atata timp cat suma pixelilor obiect(albi) nu


% depaseste pragul setat se repeta operatiile de
% detectie de contur cu un prag mai mic

BWs = edge(gray_img,'roberts', threshold * fudgeFactor);


% returneaza contururile imaginii folosind aproximarea
% de tip roberts. Contururile se gasesc in punctele
% unde gradientul imaginii este maxim

se90 = strel('line', 3, 90); % creeaza un element structural de forma


% unei linii verticale de 3 elemente
se0 = strel('line', 3, 0); % creeaza un element structural de forma
% unei linii orizontala de 3 elemente

BWsdil = imdilate(BWs, [se90 se0]);% se dilata imaginea avand ca


% element structural suma celor

32
% definite mai sus
% acest lucru se realizeaza pentru a inchide contururile
% obiectelor

BWdfill = imfill(BWsdil, 'holes'); % umple golurile din interiorul


% contururilor pentru a elimina
% eventualele contururi neinchise
% sau unii pixeli izolati

seD = strel('diamond',1); % creeaza un element structural de forma unei


% matrici de 3x3 avand ca elemente 0 in
% colturile matricii si 1 in rest

BWfinal = imerode(BWdfill,seD); % se erodeaza imaginea cu scopul de a


BWfinal = imerode(BWfinal,seD); % minimiza erorile produse de dilatare

BWfinal = bwareaopen(BWfinal,90); % elimina din imagine obiectele cu o


% dimensiune mai mica de 90 de pixeli

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

fudgeFactor = fudgeFactor - 0.1; % se decrementeaza pragul folosit daca


% aria nu este suficient de mare

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.

3.1.3. Algoritmul de eliminare al umbrelor

În vedera eliminării umbrelor rezultate în urma fotografierii am luat în considerare că


umbrele sunt cel mai apropiate de nuanţă de gri, cu uşoare influenţe ale culorii predominante a
fructului. De aici am dedus ca zonele corespunzătoare în planul RGB umbrelor trebuie să aibe
pixelii corespunzători unei poziţii apropiaţi ca valoare (în cazul unei nuanţe de gri, perfect uniforme,
pixelii asociaţi trebuie să fie de valori identice între 0 şi 255 în funcţie intensitatea griului). Astfel
am realizat o diferenţă între valorile fiecaror trei pixeli, luaţi doi câte doi, suprapuşi din planul RGB,
rezultatele urmând să fie considerate în valoare absolută. Cele trei valori astfel obţinute sunt
comparate între ele, exercitând interes doar valoarea cea mai mare. Această valoare urmează să fie
comparată cu un prag de 15 stabilit experimental, iar în cazul în care pragul este mai mare decât
valoarea maximă, pixelul respectiv va fi considerat umbră şi va prelua valoarea 0 corespunzătoare
culorii negru.

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:

function [clear_img] = elim_umbre(orig_img, contur_img)

[r,c,d] = size(orig_img); % returneaza dimensiunile imaginii:r -randuri


% c -coloane
% d adancime

for m = 1:r % se parcurge imaginea


for n = 1:c % daca in imaginea de intrare alb-
% negru
if (contur_img(m,n) == 0)% valoarea pixelului este 0(pixel
% negru
orig_img(m,n,1) = 0; % atunci fiecare valoare a pixelilor
orig_img(m,n,2) = 0; % corespunzatori din cele trei
% planuri
orig_img(m,n,3) = 0; % (r,g,b) este setata la 0
end % astfel rezulta o imagine in care
end % obiectul colorat este inconjurat de
end % negru

dist = []; % se declara vectorul distanta care va tine


% diferentele absolute dintre valorile intensitatilor
% pixelilor din planele de culori
prag = 15; % se seteaza un prag sub care pixelul este considerat
% ca avand o nuanta de gri
for m = 1:r
for n = 1:c

dist(1) = abs(orig_img(m,n,1) - orig_img(m,n,2));


% se calculeaza diferenta dintre planurile rosu si verde
dist(2) = abs(orig_img(m,n,1) - orig_img(m,n,3));
% se calculeaza diferenta dintre planurile rosu si
% albastru
dist(3) = abs(orig_img(m,n,2) - orig_img(m,n,3));
% se calculeaza diferenta dintre planurile verde si
% albastru

if max(dist) < prag % daca valoarea maxima dintre cele 3


% distante este mai mica decat pragul
% atunci in imaginea colorata pixelul
% corespunzator ia valoarea 0 (negru);
orig_img(m,n,1) = 0;
orig_img(m,n,2) = 0;
orig_img(m,n,3) = 0;

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)

3.1.4. Algoritmul de detecţie a formei

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.

Figura 25: Obţinerea formei

Î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.

Figura 26: Aplicarea conturului asupra formei

Funcţia “regionprops” măsoară proprietăţile regiunilor imaginii (analiza “petelor de


cerneală”). Aceasta măsoară un set de proprietăţi pentru fiecare regiune etichetată din matricea
etichetă L. Elementele întregi positive din L corespund unor regiuni diferite. De exemplu, setului de
elemente egale cu 1 din L corespunde regiunii 1, setul de elemente egale cu 2 corespund regiunii 2,
şi aşa mai departe. “stats” reprezintă o structură matrice, iar câmpurile conţinute în această structură
denotă diverse proprietăţi ale fiecărei regiuni, separate prin virgule în secţiunea de proprietăţi

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.

Figura 27: Rezultatul final al algoritmului de determinare a formei


function [aspect] = forma(img)

gray_img = rgb2gray(img); % se transforma in tonuri de gri imaginea


% originala

[B,L] = bwboundaries(gray_img,'noholes'); % determina matricea B in care se


% gasesc contururile obiectelor din imagine
% pt fiecare obiect in B se gaseste o matrice
% de nx2 elemente unde n este numarul de pixeli
% ce alcatuiesc conturul, pe fiecare linie din
% matrice fiind tinute coordonatele pixelilor
% din contur. De asemenea se returneaza si o
% matrice L continand etichete pentru fiecare
% obiect gasit in imagine

forma_img = label2rgb(L, @jet, 'black');% Se retin obiectele gasite si se


% transpun pe un fond negru
figure(3);
imshow(forma_img);
title('Aspectul fructului');
hold on; % se retine imaginea plotata pentru a se afisa
% contururile peste aceasta

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

stats = regionprops(L,'Area','Centroid'); % pentru fiecare obiect etichetat


% din matricea L se returneaza proprietatile
% referitoare la arie si la centrul de greutate

for k = 1:length(B) % se face o parcurgere a tuturor contururilor

boundary = B{k}; % se retin coordonatele conturului k

delta_sq = diff(boundary).^2;
perimeter = sum(sqrt(sum(delta_sq,2)));
% se calculeaza perimetrul conturului

area(k) = stats(k).Area; % se retine aria corespunzatoare conturului k

metric(k) = 4*pi*area(k)/perimeter^2;%se calculeaza o metrica care


%aproximeaza rotunjimea obiectului k

metric_string = sprintf('%2.2f',metric); % se retine rezultatul obtinut


% cu o precizie de 2 zecimale

text(boundary(1,2)-35,boundary(1,1)+13,metric_string,'Color','y',...
'FontSize',14,'FontWeight','bold'); % se afiseaza metrica obtinuta
end

[aria_max index] = max(area);

aspect = metric(index); % valoarea de retur a functiei este metrica


% corespunzatoare obiectului cu cea mai mare
% arie

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.

3.1.5. Algoritmul de determinare a dimensiunii

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:

function [size_img] = marime(clear_img)

[r,c,d] = size(clear_img); % se preiau dimensiunile imaginii

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

size_img = arie/dim; % gradul de acoperire al imaginii

Mai jos sunt indicate rezultatele obţinute în urma rulării programului Matlab pentru
obiectele: Cireaşă, Lămâie respectiv Pepene:

Cireaşă Lămâie Pepene

3.1.6. Algoritmul de detecţie a culorii

Ş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:

function [col] = color_detect (img)

[r,c,d] = size(img); % returneaza dimensiunile imaginii:r - randuri


% c - coloane
% d - adancime

contor = 0; % contorizeaza numarul de pixeli diferiti de negru

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

o = sum(p); % se face o suma a fiecarei coloane obtinand astfel trei


% valori reprezentand suma luminozitatilor tuturor
% pixelilor din imagine pentru fiecare culoare

red = (o(:,:,1)/contor)/255; % se realizeaza o medie pentru componenta de


% rosu din imagine si se normalizeaza
green = (o(:,:,2)/contor)/255; % se realizeaza o medie pentru componenta de
% verde din imagine si se normalizeaza
blue = (o(:,:,3)/contor)/255; % se realizeaza o medie pentru componenta de
% albastru din imagine si se normalizeaza

culoare = rgb2hsv([red, green, blue]); % se schimba sistemul de culori


% din RGB in HSV
col = culoare(1)*255; % re returneaza valoarea denormalizata a componentei
% de nuanta

Mai jos sunt indicate rezultatele obţinute în urma rulării programului Matlab pentru
obiectele: Cireaşă, Lămâie respectiv Pepene:

Cireaşă Lămâie Pepene

3.1.7. Algoritmul de returnare a obiectelor şi a stării acestora

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ă:

function rez = rec_fruct(val_fr)

slf=readfis('SLF.fis');
ValFruct = evalfis(val_fr, slf);

if -0.1 < ValFruct(1,1) & ValFruct(1,1) <= 0.5


TipFruct=' mar';
end

if 0.5 < ValFruct(1,1) & ValFruct(1,1) <= 1.5


TipFruct=' piersica';
end

if 1.5 < ValFruct(1,1) & ValFruct(1,1) <= 2.5


TipFruct=' caisa';
end

if 2.5 < ValFruct(1,1) & ValFruct(1,1) <= 3.5


TipFruct=' lamaie';
end

if 3.5 < ValFruct(1,1) & ValFruct(1,1) <= 4.5


TipFruct=' portocala';
end

if 4.5 < ValFruct(1,1) & ValFruct(1,1) <= 5.5


TipFruct=' cireasa';
end

if 5.5 < ValFruct(1,1) & ValFruct(1,1) <= 6.5


TipFruct=' avocado';
end

if 6.5 < ValFruct(1,1) & ValFruct(1,1) <= 7.5


TipFruct=' banana';
end

if 7.5 < ValFruct(1,1) & ValFruct(1,1) <= 8.5


TipFruct=' pepene';
end

43
if -0.1 < ValFruct(1,2) & ValFruct(1,2) <= 0.5
StareFruct = ' necopt';
else
StareFruct = ' copt';
end

rez = strcat('Tipul fructului este',TipFruct,' iar starea sa este', StareFruct);


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

3.1.8. Funcţia principală

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

clear_img = elim_umbre(img, contur_img); % se elimina umbrele din imaginea


% obtinuta anterior

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

disp(['Aspectul = ', num2str(aspect)]); % afisarea valorii


% aspectului
%% Determinare dimensiune
dimensiune = marime(clear_img); % se determina o valoare intre 0 si 1
% reprezentand gradul de acoperire al
% imaginii (dimensiunea fructului)

disp(['Dimensiunea = ', num2str(dimensiune)]);% se afiseaza dimensiunea

%% Determinare culoare
culoare = color_detect(clear_img); % algoritmul de detectie al culorii

disp(['Culoarea = ', num2str(culoare)]); % se afiseaza valoarea nuantei


% din sistemul hsv

%% Recunostere fruct

val_fr = [aspect dimensiune culoare];

fruct = rec_fruct(val_fr);

disp(fruct)

3.2. Proiectarea Sistemului cu Logică Fuzzy în determinarea tipului fructului şi


stării acestuia

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:

Figura 28: Modelul sistemului fuzzy

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:

Figura 29: Editarea Regulilor

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

3.2.1.2. Definirea mulţimilor fuzzy pentru variabila de intrare dimensiune

Universul discuţiei variabilei de intrare dimensiune, notată Dimensiune, se defineşte pe


intervalul [0;0,45].

Pentru definirea mulţimilor fuzzy pentru variabila de intrare Dimensiune se foloseşte o


acoperire a universului variabilei de intrare, prin două mulţimi trapezoidale asimetrice (FoarteMic
şi FoarteMare) şi trei mulţimi triunghiulare asimetrice (Mic, Mediu, Mare) astfel încât cele cinci
mulţimi nu formează o partiţie datorită intervalului de definire a mulţimilor Mare şi FoarteMare
după cum se observă în figuta de mai alăturată. Intervalul de definire a 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.

47
Figura 31: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Dimensiune

3.2.1.3. Definirea mulţimilor fuzzy pentru variabila de intrare culoare

Universul discuţiei variabilei de intrare culoare, notată Culoare, se defineşte pe intervalul


[0;45].
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 (Roşu, Portocaliu,
Galben, Verde) astfel încât cele patru mulţimi să formeze o partiţie fuzzy. La fel ca şi în cazurile de
mai sus intervalul de definire a universului discuţiei şi a mulţimilor fuzzy conţinute în acesta a fost
obţinut pe baza rezultatelor experimentale obţinute în urma rulării scriptului Matlab pentru
extragerea caracteristicilor obiectelor din imagini. Iniţial universul discuţiei pentru variabila de
intrare Culoare a fost definit pe intervalul [0;255]. În această reprezentare, universul discuţiei este
domeniul valorilor posibile pentru nuanţă, X=[0;255], iar variabila din universul discuţiei este
nuanţa. Pentru fiecare culoare vom avea definită câte o mulţime fuzzy. Ca urmare avem un total de
zece mulţimi fuzzy, cu funcţiile de apartenenţa notate prin: Roşu, Orange, Galben, Verde, Cyan,
Albastru, Purpuriu, Mov, Roz şi iarăşi Roşu cu valori în [0;255], formând o partiţie. Pentru
simplitatea reprezentării, alegem o abordare simplă din literatură de specialitate în care cele zece
mulţimi sunt reprezentate prin funcţii de apartenenţa liniare pe porţiuni (triunghiulare şi
trapezoidale). Aşezare este identică cu cea a unui cerc trigonometric intrarea având ca mulţime de
început şi sfârşit mulţimea Roşu. În urma extragerii caracteristicilor de culoare din obiectele pozate
s-a observat un anumit decalaj intre valoarea culorii medii a obiectului şi corespondentul acesteia
din intrarea Culoare. De exemlu, pentru Avocado, un fruct de culoare verde intens (specificată pe
axa culorilor prin intervalul[62;119]), valoarea culorii medii extrase de algoritmul de detecţie a
culorii este de aproximativ 40 corespunzător culorii galben pe axa culorilor. În urma stabilirii
regulilor sistemului cu logică nuanţată, regula asociată fructului Avocado nu va fi activată datorită
existenţei acestui decalaj, acest fapt conducând la erori în afişarea rezultatelor finale. Cele zece
mulţimi şi parametrii lor sunt prezentate în figură de mai jos:

48
Figura 32: Mulţimile fuzzy initiale peste universul discuţiei variabilei de intrare Culoare

În vederea eliminării acestui impediment am considerat o variabilă de intrare Culoare, nouă,


definită pe intervalul [0;45]. Intervalele considerate pentru mulţimile fuzzy conţinute în aceasta au
fost determinate experimental, fiind luate în calcul doar mulţimile fuzzy corespunzătoare culorilor
din a căror combinaţie se pot obţine nuanţele întâlnite în majoritatea cazurilor la fructe. Aceste
mulţimi sunt reprezentate în figură de mai jos:

Figura 33: Mulţimile fuzzy finale peste universul discuţiei variabilei de intrare Culoare

3.2.2. Ieşirile

3.2.2.1. Definirea mulţimilor fuzzy pentru variabila de ieşire tipul fructului

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

3.2.2.2. Definirea mulţimilor fuzzy pentru variabila de ieşire a stării


fructului
La fel ca şi în cazul variabilei TipFruct, şi în cazul variabilei de ieşire care reflectă starea
fructului, denumită generic StareFruct, trebuie avut în vedere că sistemul cu logică fuzzy are
caracter decizional. Universul discuţiei în cazul acesteia este cuprins în intervalul [-0.1;1.1], iar
mulţimile fuzzy asociate variabilei de ieşire StareFruct sunt în număr de două, respectiv Necopt şi
Copt fiecare definite pe un întreg din intervalul de mai sus, cu o lăţime la stânga şi respectiv dreapta
de 0.1. Cele două mulţimi, illustrate în figură de mai jos, sunt mulţimi fuzzy triunghiulare, definite
astfel încât nu formează o partiţie fuzzy.

Figura 35: Mulţimile fuzzy peste universul discuţiei variabilei de iesire StareFruct

3.2.3. Definirea setului de reguli pentru SLF

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)

• 4. If (Aspect is Rotund) and (Dimensiune is FoarteMic) and (Culoare is Verde) then


(TipFruct is Cireasa)(StareFruct is Necopt) (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)

• 7. If (Aspect is Rotund) and (Dimensiune is Mediu) and (Culoare is Portocaliu) then


(TipFruct is Caisa)(StareFruct is Copt) (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)

3.2.4. Funcţionarea sistemului cu logică fuzzy

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

Rezultatele obţinute în urma proiectării sistemului de sortare sunt prezentate în figurile de


mai jos, prin intermediul a trei grafice tridimensionale ce indică tipul fructului, şi a altor trei ce
indică starea fructului în funcţie de cele trei intrări considerate două câte două.

Figura 37: Ieşirea TipFruct în funcţie de întărările Aspect şi Dimensiune

Figura 38: Ieşirea StareFruct în funcţie de intrările Dimensiune şi Culoare

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

În această lucrare a fost prezentată o metodologie eficientă de proiectare bazată pe model


pentru implementarea unui sistem de sortare pe bază de logică fuzzy. Utilizând această metodologie,
sistemul decizional poate fi ajustat şi testat în totalitate în mediul de simulare fără prea mari eforturi
sau costuri ridicate specifice anumitor sisteme de dezvoltare softwear. Rezultatele experimentale au
dovedit eficienta metodologiei propuse.
Conform experimentelor realizate, în urma fotografierii obiectelor au fost sesizate diferite
distorsiuni asupara obiectelor în special asupra culorii acestora. Astfel în cazul tructului “avocado”
care are culoarea verde intens, corespunzător pe axa culorilor intervalului [80;90], se obţinea în
urma rulării algoritmului de detecţie a culorii valoarea aproximativă de 39 care nu aparţine acestui
interval, acest fapt ducând la obţinerea de rezultate eronate. Astfel a fost nevoie de definirea unor
noi mulţimi fuzzy pentru variabila de intrare Culoare în funcţie de rezultatele experimentale obţinute
pentru baza de date. Pentru variabila de intrare Aspect s-a definit ulterior primelor experimente o
nouă mulţime fuzzy ddenumita generic Neregulat care să ofere mai multă acurateţe în determinarea
formei corespunzătoare fiecărui obiect de selectat. În cazul variabilei de intrare Dimensiune cele
cinci mulţimi fzzy definite la începutul proiectării au fost menţinute până în final datorită
corectitudinii rezultatelor obţinute pe parcursul experimentelor. De remarcat că aceste mulţimi nu
formează o partiţie, iar modul de creştere o domeniilor de definiţie nu respectă o anumită regulă de
proporţionalitate.
Acest sistem de clasificare a fost proiectat ţinând cont că intrarea lui constă în imagini color
ale obiectelor de clasificat. Datele furnizate de algoritmii de extragere a celor trei caracteristici
(aspect fizic, dimensiune, culoare) reprezintă intrări pentru sistemul decizional cu logică fuzzy, date
pentru care rezultatele obţinute au fost foarte bune. Totuşi sistemul poate fi ajustat în precizie prin
introducerea unei noi variabile de intrare în sistemul de sortare, de tip “textură” care să cuantizeze
ţesutul obiectului din imagine într-o valoare numerică. De asemenea, cardinalul mulţimilor fuzzy
pentru variabila de intare culoare poate fii extins cu mulţimi corespunzătoare unor color noi pentru a
mări plajă de obiecte care pot fi clasificate. Nu în ultimul rând, o altă îmbunătăţire care poate fi
adusă sistemului se referă la ieşirile acestuia. Ieşirea ce indică tipul fructului poate fi extinsă prin
îmbogăţirea bazei de date cu alte tipuri de fructe, precum şi cu o mulţime fuzzy ce indică eroarea în
cazl în care obiectul din imaginea introdusă la intrare nu corespunde cu nici un alt obiect din baza de
date.

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