UNIVERSITATEA TEHNICĂ DIN CLUJ-NAPOCAFACULTATEA DE ELECTRONICĂ, TELECOMUNICAŢII ŞI

TEHNOLOGIA INFORMAŢIEISpecializarea: 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ă fuzzyTipul proiectului: dezvoltare şi implementare de softwareCerinţ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 CIORTEA2. 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

Date of birth: 14thof May, 1987

Studies:2002 – 2006 : “Emil Racoviţa” Naţional College of Cluj-Napoca, Cluj2002 – 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 Departament2009 – 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: WellFrench Conversation: Acceptable

Writing: AcceptableReading: Acceptable

Contact:Adress: Avram Iancu St., No. 3, Ap. 17, Huedin, Cluj-NapocaPhone: 0748-426680E-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

- nu sunt de accord

5

Planificarea activităţii

Cuprins

1. Studiu bibliografic.............................................................................................................................92. Fundamentare teoretica...................................................................................................................11

2.1. Metodologia propusa................................................................................................................112.2. Logica Fuzzy............................................................................................................................12

2.2.1. Mulţimile fuzzy.................................................................................................................132.2.2. Variabile lingvistice..........................................................................................................142.2.3. Grade de adevăr.................................................................................................................142.2.4. Aplicarea valorilor de adevăr............................................................................................152.2.5. Raţionament fuzzy............................................................................................................152.2.6. Proprietăţile mulţimilor fuzzy...........................................................................................172.2.7. Sisteme cu logică fuzzy.....................................................................................................182.2.8. Sisteme cu locica fuzzy Takagi-Sugeno...........................................................................19

6

2.2.9. Sistemele cu logică fuzzy Mamdani.................................................................................202.3. Mediul de programare MATLAB............................................................................................21

2.3.1. Image Acquizition Toolbox..............................................................................................222.3.2. Image Processing Toolbox................................................................................................222.3.3. Afişarea şi explorarea imaginilor......................................................................................232.3.4. Procesarea şi postprocesarea imaginilor...........................................................................232.3.5. Proiectarea şi simularea sistemelor fuzzy în MATLAB cu Fuzzy Logic Toolbox...........232.3.6. Utilizarea Fuzzy Logic Toolbox.......................................................................................242.3.7. Construirea unui sistem de inferenţă fuzzy.......................................................................242.3.8. Modelarea utilizând logică fuzzy......................................................................................262.3.9. Defuzzificarea...................................................................................................................26

3. Proiectare şi rezultate experimentale...............................................................................................293.1. Extragerea caracteristicilor obiectelor......................................................................................29

3.1.1. Achiziţia imaginilor..........................................................................................................293.1.2. Algoritmul de detecţie a conturului...................................................................................303.1.3. Algoritmul de eliminare al umbrelor.................................................................................333.1.4. Algoritmul de detecţie a formei........................................................................................373.1.5. Algoritmul de determinare a dimensiunii.........................................................................403.1.6. Algoritmul de detecţie a culorii.........................................................................................413.1.7. Algoritmul de returnare a obiectelor şi a stării acestora....................................................433.1.8. Funcţia principală..............................................................................................................44

3.2. Proiectarea Sistemului cu Logică Fuzzy în determinarea tipului fructului şi stării acestuia. . .463.2.1. Intrări.................................................................................................................................473.2.1.1. Definirea mulţimilor fuzzy pentru variabila de intrare aspect.......................................473.2.1.2. Definirea mulţimilor fuzzy pentru variabila de intrare dimensiune...............................473.2.1.3. Definirea mulţimilor fuzzy pentru variabila de intrare culoare......................................483.2.2. Ieşirile................................................................................................................................493.2.2.1. Definirea mulţimilor fuzzy pentru variabila de ieşire tipul fructului.............................493.2.2.2. Definirea mulţimilor fuzzy pentru variabila de ieşire a stării fructului..........................503.2.3. Definirea setului de reguli pentru SLF..............................................................................513.2.4. Funcţionarea sistemului cu logică fuzzy...........................................................................523.2.5. Rezultatele proiectării sistemului de sortare.....................................................................543.2.6. Defuzzificarea...................................................................................................................55

4. Concluzii.....................................................................................................................................565. Bibliografie.....................................................................................................................................57Index de imagini continute in text

Figura 1: Schemă logică pentru metodologia propusă........................................................................11Figura 2: Ilustrarea mulţimilor “TRUE” şi “FALSE” în logica booleană (a) şi în logica fuzzy (b)...12Figura 3: Cele 11 tipuri de mulţimi fuzzy...........................................................................................14Figura 4: Inferenţa compoziţională.....................................................................................................17Figura 5: Schema bloc a unui sistem cu logică fuzzy........................................................................19Figura 6: Prelucrarea semnalelor într-un sistem cu logică fuzzy Takagi-Sugeno...............................20Figura 7: Structura unui sistem cu logică fuzzy Mamdani.................................................................21Figura 8: Interpretarea diagramei fuzzy de inferenţa de tip Mamdani................................................21Figura 9: Editorul FIS.........................................................................................................................24Figura 10: Editorul de funcţii membre................................................................................................25Figura 11: Afişarea suprafeţelor..........................................................................................................25Figura 12: Metoda maximului funcţiei de apartenenţa.......................................................................27

7

Figura 13: Metoda centrului de masă..................................................................................................27Figura 14: Metoda mediei ponderate..................................................................................................28Figura 15: Metoda mediei maximelor.................................................................................................28Figura 16: Rezultatul obţinut în urma rulării funcţiei “edge”.............................................................30Figura 17: Rezultatul obţinut în urma rulării funcţiei “imdilate”........................................................31Figura 18: Rezultatul obţinut în urma rulării funcţiei “imfill”............................................................31Figura 19: Rezultatul final al aplicarii algoritmului............................................................................32Figura 20: Imaginea originală pe fundal negru (înainte de aplicarea algoritmului de eliminare a umbrelor).............................................................................................................................................35Figura 21: Imaginea fără umbre pe fundal negru (rezultată în urma aplicării algoritmului de eliminare a umbrelor cu prag 15)........................................................................................................35Figura 22: Imaginea originală pe fundal alb (înaintea de aplicarea algoritmului de eliminare a umbrelor).............................................................................................................................................36Figura 23: Imaginea fără umbre pe fundal alb (rezultată în urma aplicării algoritmului de eliminare a umbrelor cu prag 90)...........................................................................................................................36Figura 24: Imaginea fără umbre pe fundal alb (rezultată în urma.......................................................37Figura 25: Obţinerea formei................................................................................................................38Figura 26: Aplicarea conturului asupra formei...................................................................................38Figura 27: Rezultatul final al algoritmului de determinare a formei...................................................39Figura 28: Modelul sistemului fuzzy..................................................................................................46Figura 29: Editarea Regulilor..............................................................................................................46Figura 30: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Aspect.............................47Figura 31: Mulţimile fuzzy peste universul discuţiei variabilei de intrare Dimensiune.....................48Figura 32: Mulţimile fuzzy initiale peste universul discuţiei variabilei de intrare Culoare................49Figura 33: Mulţimile fuzzy finale peste universul discuţiei variabilei de intrare Culoare..................49Figura 34: Mulţimile fuzzy peste universul discuţiei variabilei de iesire TipFruct............................50Figura 35: Mulţimile fuzzy peste universul discuţiei variabilei de iesire StareFruct..........................50Figura 36: Fereastra Rule Viewer.......................................................................................................53Figura 37: Ieşirea TipFruct în funcţie de întărările Aspect şi Dimensiune.........................................54Figura 38: Ieşirea StareFruct în funcţie de intrările Dimensiune şi Culoare.......................................54

1. Studiu bibliografic

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 situaţii delicate: nu toate sistemele reale sunt clare şi deterministe (ca atare nu pot fi descrise cu

8

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 teoreticaLogica 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

{ ( ) / }AA 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:

1 1 2 21

/ / ... / /n

n n i ii

A x x x x

Dacă funcţia de apartenenţa este o funcţie continuă, atunci mulţimea fuzzy A se scrie ca:

( ) /A

X

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

( ) : [0;1]A x X

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

{( , ( )) | }AA x 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:

“ este ”

unde este o variabilă lingvistică iar este o valoare lingvistică a variabilei . Înţelesul acestei propoziţii este determinat de mulţimea fuzzy definită pe universul discuţiei variabilei . Regulile fuzzy sunt propoziţii condiţionale de tipul DACĂ-ATUNCI care folosesc variabile şi valori lingvistice fuzzy:

“ Daca este atunci este ”

unde şi sunt valori lingvistice definite prin mulţimi fuzzy pentru variabilele lingvistice , respectiv y.

Partea DACĂ a regulii ( este ) se numeşte premisă sau antecedent, pe când partea ATUNCI ( este ) 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

unde şi sunt mulţimile fuzzy şi modificate.

Aflarea concluziei se realizează în urma procesului de inferenţă (deducţie) fuzzy, care matematic se poate rezolva folosind regula compoziţională de inferenţă propusă de Zadeh:

= o ( )

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:

Trebuie stabiliţi operatorii pentru cele două operaţii: implicaţie şi compunere. Pentru implicaţie cei mai folosiţi operatori sunt:

min

(Mamdani)

produs (Larsen)

Pentru compunere cel mai des se foloseşte compunerea max-min:

,

unde şi sunt universurile discuţiei pentru cele două variabile, respectiv .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

,

Inferenţa compoziţională max-produs, sau Larsen

,

* 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 *, inferenţa compoziţională max-min se reduce la formula:

,

,

În cazul în care mulţimea fuzzy este de tip Takagi-Sugeno de ordin zero (mulţime fuzzy

16

premisă implicaţie concluzieconcluzie

este

DACĂ este ATUNCI este bbbbbbberww n este

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:

( ) 1x x

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

{ | ( ) }AA x 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

18

Fuzzificare Inferenţă DefuzzificareA* B* y*x*

Valori tranşante de intrare

Valori tranşante de ieşire

Mulţimi fuzzy de intrare (A)

Mulţimi fuzzy de ieşire (B)

Baza dereguli fuzzy

Baza de cunoştinţe

mulţimi şi reguli fuzzy

flux

info

rmaţ

iona

l

flux de calcul

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 ( *) în

mulţimi fuzzy de tip singleton ( *); Baza de cunoştinţe =: furnizează modulului Inferenţă informaţiile necesare:

- mulţimile fuzzy pentru variabilele de intrare ( );- mulţimile fuzzy pentru variabilele de ieşire ( );- baza de reguli fuzzy.

Inferenţă =: blocul care determină valorile fuzzy ale variabilelor de ieşire ( *) folosind inferenţa fuzzy;

Defuzzificare =: interfaţa ce transformă valorile fuzzy ale variabilelor de ieşire în valori tranşante ( *).

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 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 * şi *

ale variabilelor de intrare sunt fuzzificate rezultând mulţimile fuzzy singleton *, respectiv *.

Gradele de activare (adevăr) ale celor două reguli sunt , respectiv ş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 * şi * în

cazul unui SLF T-S de ordin zero, respectiv * şi * î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ă * a variabilei de ieşire corespunzătoare valorilor tranşante * şi * 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ă şi a doua - de formă triunghiulară . În general, ieşirea fuzzy a unui process poate implică mai multe funcţii de apartenenţa fuzzy de diferite forme; în acest caz

. Corespunzător convenţiei adoptateexista mai multe metode de defuzzificare, alegerea

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 , pentru care , (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 ( ) 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 (Figura 13) conform relaţiei: .

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

Figura 14: Metoda mediei ponderate

d) Metoda mediei maximelor presupune calculul lui (Figura 15) unde:

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-adancimeprag = (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 elementese0 = 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

endend fudgeFactor = fudgeFactor - 0.1; % se decrementeaza pragul folosit daca % aria nu este suficient de mare endcontur_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 grifor 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 endend

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

37

Matricea etichetă L este văzută, de asemenea, ca prim parametru al acestei funcţii. Cel deal doilea 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 n3 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

, 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 obtinutaend [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 endend 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 endend 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 HSVcol = 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 conturcontur_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 formaaspect = 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

50

într-o anumită stare. Regulile de tip “If…then…/Dacă…atunci…” ale sistemului cu logică fuzzy reflectă 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

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