UNIVERSITATEA POLITEHNICA BUCUREŞTI

FACULTATEA DE AUTOMATICĂ ŞI CALCULATOARE

DEPARTAMENTUL AUTOMATICĂ

SISTEME INTELIGENTE DE CONDUCERE

MASTER

PROIECT DE DIZERTAŢIE

APLICAŢIE PENTRU INTERPRETAREA IMAGINILOR

ACHIZIŢIONATE DE LA UN VEHICUL

Absolvent:
Coordonator ştiinţific: BÃLÃCEANU I. ANDREI
CONF. DR. ING. IOAN ȘTEFAN SACALÃ

BUCUREŞTI

Iunie 2016
CUPRINS
1.INTRODUCERE.....................................................................................................................3
2.STUDIUL ACTUAL AL APLICATIILOR EXISTENTE ÎN DOMENIU..............................7
2.1 NVIDIA DRIVE PX.........................................................................................................7
2.2.VEHICULUL AUTONOM DE LA GOOGLE................................................................8
2.3.SISTEMELE DE ASISTENŢĂ A ŞOFERULUI MOBILEYE.......................................9
2.4.SISTEMELE DE ASISTENŢĂ A ŞOFERULUI PLK TECHNOLOGIES...................11
2.5.SISTEME DE ASISTENŢĂ A ŞOFERULUI OFERITE DE LUXOFT.......................12
2.6.SOLUŢII OFERITE DE COMPANIA ITSEEZ.............................................................13
2.7.CERCETĂRI REALIZATE DE MERL (MITSUBISHI ELECTRICRESEARCH
LABORATORY)..................................................................................................................14
3.DESCRIEREA SOLUŢIEI PROPUSE..................................................................................15
3.1.ELEMENTE GENERALE.............................................................................................15
3.2.MOTORUL GRAFIC UNITY.......................................................................................17
3.3. LIBRĂRIA OPENCV...................................................................................................18
3.4.LIBRĂRIA EMGUCV...................................................................................................19
3.5.STRUCTURA APLICAŢIEI..........................................................................................20
3.6.TRANSFORMAREA ÎN IMAGINI CU TONURI DE GRI..........................................23
3.7.EXTRAGEREA CONTURURILOR FOLOSIND ALGORITMUL CANNY..............24
3.8.FILTRUL DE TIP NETEZIRE GAUSSIANĀ...............................................................26
3.9.FILTRUL DE TIP THRESHOLDING...........................................................................28
3.10.RECUNOAŞTEREA DRUMULUI.............................................................................29
3.11.RECUNOAŞTEREA SEMNULUI DE DE CIRCULAŢIE STOP..............................33
3.12.RECUNOAŞTEREA ALTOR VEHICULE.................................................................35
3.13.RECUNOAŞTEREA PIETONILOR...........................................................................37
3.14.RECUNOAŞTEREA SEMAFORULUI......................................................................41
3.15.CONTROLUL MAŞINII.............................................................................................43
3.16.REZULTATELE SIMULĂRII.....................................................................................45
4.CONCLUZII..........................................................................................................................47
5.ANEXE..................................................................................................................................49
5.1.ANEXA 1 CLASA CAPTURARE TEXTURA.............................................................49
5.2.ANEXA 2 CLASA DETECTOR...................................................................................50
5.3.ANEXA 3 CLASA MASINA.........................................................................................51
5.4.ANEXA 4 CLASA DETECTIE PIETONI.....................................................................51
5.5.ANEXA 5 CLASA DETECTIE BENZI........................................................................52
5.6.ANEXA 6 CLASA DETECTIE SEMN STOP..............................................................53
5.7.ANEXA 7 CLASA DETECTIE SEMAFOR.................................................................55
5.8.ANEXA 8 CLASA DETECTIE MASINI......................................................................56
6.BIBLIOGRAFIE....................................................................................................................58

2
1.INTRODUCERE

Majoritatea informațiilor pe care omul le extrage din mediul înconjurător

vin în formă vizuală . Cantitatea de informație din mediul înconjurător
influențează foarte mult șansele și corectitudinea atingerii unor obiective
predefinite . Pentru a extrage cât mai multe informații utile din mediu un sistem
artificial beneficiază dacă ar avea capacitatea de viziune . Încă din anii 60 s-a
pus problema recunoașterii lumii înconjurătoare și extragerea de date esențiale
din mediu de către sistemele informatice .

Oamenii pot vedea și recunoaște o multitudine de obiecte într-o scenă cu

efort minim , chiar dacă aceste obiecte nu apar complet în cadru , sunt acoperite
de alte obiecte , apar de dimensiuni diferite , sunt rotite etc. Capabilitățile omului
de vedere s-au dezvoltat prin milioane de ani de evoluție dar capabilitățile
tehnologice de înregistrare a imaginilor și extragerea de informații utile din
acestea este un domeniu recent , bazele domeniului cunoscut astăzi ca vizune pe
calculator (Computer Vision) au fost puse în anii 1950 .

La început s-a încercat imitarea ochiului uman dar structura acestuia este
foarte complexă și medicina curentă nu are o înțelegere completă a
mecanismelor vederii . De asemenea , adaptarea modelului organic al ochiului
unei structuri inorganice prezintă probleme . Din aceste motive , s-au căutat alte
abordări în alte domenii , cele mai bune rezultate realizându-se folosind principii
geometrice . Odata cu scăderea costului camerelor video , creșterea calităţii
imaginilor acestora precum și creșterea puterii de procesare a calculatoarelor ,
domeniul vederii artificiale s-a maturizat .

În ziua de astăzi , oricine are acces la camere care pot captura imagini de
calitate foarte bună în orice condiții , un exemplu fiind camerele de pe
smartphone-uri care folosesc algoritmi pentru procesarea imaginilor pentru a
compensa absenţa obiectivelor . Multe din problemele recunoașterii obiectelor
din imagini rămân nerezolvate și în ziua de astăzi .

Vederea artificialā , ca domeniu , are scopul de a produce informații

relevante , de regulă identificarea , memorarea și clasificarea de obiecte , prin
prelucrarea , analiza , și înțelegerea imaginilor din lumea reală transformate în
reprezentări simbolice în memoria calculatorului .

Înțelegerea imaginilor în acest context înseamnă transformarea imaginilor

vizuale în descrieri ale lumii reale . Sub-domenii ale vederii artificiale includ
reconstrucția de scene, supravegherea video, recunoașterea obiectelor, estimarea
mișcării și restaurarea de imagini.

3
 Domeniile de aplicabilitate variază în funcţie de obiectivele care aceste
sisteme le pot îndeplini .

Exemple de aplicații ale viziunii artificiale includ :

- Sisteme pentru controlul proceselor ;
- Sisteme de navigare (ex: un robot mobil );
- Sisteme de detectare , cum ar fi cele pentru supraveghere ;
- Sisteme pentru organizarea informațiilor , cum ar fi , de exemplu,
sistemele pentru indexarea imaginilor și a secvențelor video în baze de date;
- Sisteme pentru modelarea obiectelor sau modelarea mediilor , cum ar fi ,
de exemplu, analiza imaginilor medicale sau modelarea topografică;
- Sisteme de interacțiune , cum ar fi , interfeţe pentru interacțiunea om-
calculator;
- Sisteme pentru inspecție automată , cum ar fi , de exemplu , controlul
calităţii în aplicații de fabricație.

Unul dintre domeniile recente în care se aplică aceste metode este în cazul
vehiculelor autonome . În categoria vehiculelor autonome intră vehiculele
acvatice (USV – Unmanned Surface Vehicle) , vehicule terestre (UGV –
Unmanned Ground Vehicle) , vehicule aeriene (UAV – Unmanned Aerial
Vehicle ) . Complexitatea sistemelor vizuale de pe aceste vehicule depinde de
autonomia care se dorește . Aceastea variază de la sisteme complexe de
recunoaștere a elementelor esențiale din mediu , precum persoane , drum , sol ,
zone de aterizare , clădiri , asistate de alte sisteme precum detectori pentru
distanţă , sonare , GPS și sisteme de luare a deciziilor , în cazul vehiculelor
complet autonome , fără pilot , pană la vehicule în care sistemele bazate pe
vedere doar furnizează unui pilot informaţii în diferite situații .

Rolul principal al sistemelor vizuale în cazul vehiculelor , indifrent de

mediul pe care acestea rulează , este navigarea , acestea având nevoie de
informații pentru orientare sau pentru a produce o imagine a mediului
înconjurător . Un rol secundar poate fi detectarea de evenimente sau puncte de
interes în funcţie de domeniul de utilizare sau rolul sistemului . De exemplu, un
UAV în căutarea unor incendii forestiere , un UGV care dezamorsează bombe .

În majoritatea cazurilor din realitate , în momentul prezent , sistemele de

vedere artificială se folosec pentru asistenţa pilotului sau a utilizatorului .
Exemple includ sisteme de avertizare a obstacolelor în vehicule terestre , și
sisteme pentru facilitarea aterizării vehiculelor aeriene .

Pentru a putea înțelege informațiile dintr-o imagine aceasta trebuie trecută

prin mai multe tipuri de filtre și prin mai multe niveluri de abstractizare pentru a
elimina detaliile care nu sunt necesare .

Multe sisteme de vedere artificială trec prin urmatorii pași :

1) Achiziția imaginii de la senzori . Acești senzori includ diverse tipuri de
camere sensibile la lumina dar pot include și senzori de distanţă, radare, camere
ultra-sonice etc. În funcție de tipul de senzor, rezultatele obţinute pot fi imagini
bidimensionale , modele tridimensionale , sau o secvență video ;

4
 2) Pre-procesare . Înainte de a aplica o metodă de vedere artificialā pentru
a extrage informații , este de obicei necesară procesarea datelor pentru a asigura
că acestea îndeplinesc anumite condiții . Acest pas , de regulă , presupune
trecere imaginilor prin o multitudine de filtre . Exemple sunt : reducerea
zgomotului pentru reducerea informațiilor false , îmbunătățirea contrastului etc.;

3) Extracție de caracteristică . Prin caracteristici ne referim la : linii,

muchii, creste , colțuri, pete sau puncte . Mai multe caracteristici complexe pot fi
legate de textură, formă sau mișcare . Acest pas ajută la simplificarea imaginii și
orientarea pe elemente esenţiale din aceasta care facilitează etapele următoare ;

4) Detectare / Segmentare . În acest pas imaginea este prelucrată pentru

a analiza și extrage elementele care ne interesează din imagine . Aceste
elemente pot apărea sub formă de puncte de interes sau regiuni relevante pentru
scopul sistemului. Exemple sunt: selectarea coordonatelor unui set specific de
puncte de interes , segmentarea (separarea) uneia sau a mai multor regiuni de
imagine care conțin un anumit obiect de interes ;

5) Prelucrare la nivel înalt . În această etapă algoritmii se concentrează pe

zonele extrase la punctul 4 care constau de obicei dintr-un mic set de date , cum
ar fi , seturi de puncte sau o regiune de imagine care se presupune să conțină
obiectul cautat . Procesarea în această etapă se ocupă , de exemplu , cu
verificarea că datele îndeplinesc ipotezele modelelor , estimarea parametrilor
căutați de aplicație , cum ar fi poziția obiectelor sau dimensiunea lor , clasificarea
unui obiect detectat în diferite categorii , compararea și combinarea a două
puncte de vedere diferite ale aceluiași obiect etc. ;

6)Luarea deciziilor . Această etapă constă în luarea deciziei finale în funcție

de scopul aplicației , cum ar fi admis / respins în funcţie de cererile aplicației ,
asemănarea cu un tipar , marcarea pentru o nouă reexaminare de un operator
uman etc. [2]

Un sistem de vedere artificială de regulă se concentrează pe detecţia unui

anumit tip de caracteristică . Prin caracteristică ne referim aici la elementele cele
mai simple din imagine din care rezultă cea mai mare informație relevant .

Tipuri de caracteristici de imagine după care un sistem se uită includ:

- Margini , care sunt puncte unde există o limită între două regiuni de
imagine . În practică, marginile sunt de obicei definite ca seturi de puncte , care
au o magnitudine de gradient puternic . Algoritmii vor înlănțui puncte ridicate de
gradient pentru a forma o descriere completă a unei muchii . Aceşti algoritmi
plasează constrângeri pe proprietățile unei margini , cum ar fi forma marginii,
netezimea acesteia , valoarea gradientului ;
- Colțurile , care se referă la caracteristici punctiforme dintr-o imagine,
care au o structură de două dimensiuni locale . Algoritmii iniţiali analizau
marginile pentru a găsi schimbări rapide de direcție acestea reprezentând
colţurile . Aceştia au fost apoi îmbunătăţiţi , astfel încât detectarea marginii
explicit nu mai era necesară ;

5
 - Petele , care oferă o descriere mai complexă a structurilor de imagine în
ceea ce privește regiunile . Descriptorii de tip pete pot conține adesea un punct
preferat (un maxim local sau un centru de greutate) .
- Creste , care sunt primele elemente după care ne uitam în cazul
obiectelor alungite . Din punct de vedere practic, o creastă poate fi gândită ca o
curbă unidimensională .

Domeniul viziunii pe calculator poate fi folositor în multe domenii deoarece

captura de imagine este un proces non-distructiv și discret .

În această lucrare voi prezenta o aplicație care detectează o serie de

elemente din mediul înconjurator utile pentru asistenţa unui şofer al unui
autovehicul . Autovehiculul și mediul înconjurător vor fi simulate într-un spaţiu
tridimensional .

Conform ASIRT(Association for Safe International Road Travel) în fiecare

an 1.3 milioane de oameni mor în accidente rutiere , ceea ce înseamnă că în jur
de 3,287 de oameni mor în medie pe zi , în întreaga lume . Adiţional între 20-50
de milione de oameni sunt răniți anual în accidente care implică autovehicule .
[12]

Mai mult de jumate din fatalităţile cauzate de accidente între autovehicule

sunt adulţi cu vârste cuprinse între 15 și 44 de ani . Fatalităţile din cauza
accidentelor sunt pe locul 9 și reprezintă 2.2% din toate cauzele morții global pe
an . Accidentele de mașină implică cheltuieli de peste 518 miliarde de dolari
anual suportate de statele în care se produc acestea . Estimările de viitor
plasează o creștere în rata fatalităţilor din cazul accidentelor de mașină ajungând
pe locul 5 ca principală cauză în cadrul morților global anuale până în anul 2030 .
[12]
Rata fatalităţilor în cazul accidentelor de mașină a scăzut comparativ cu
anii 70-80 dar încă este destul de mare global . Majoritatea acestor accidente
sunt din vina șoferilor și puteau fi ușor evitate .

Atenția omului este limitată , acesta nu se poate concentra intens mai mult
de 9 secunde pe un anumit element . De asemenea , atenţia nu este distributivă
acesta neputând să se concentreze pe mai mult de 4 lucruri în același timp . În
ziua de astăzi există mulți factori care pot acapara atenția șoferului în timp ce
acesta conduce , de la pasageri pană la dispozitive electronice personale .
Reacția omului este de asemenea limitată . Media timpului de reacție a unui adult
este de 276 de milisecunde . [13]

Toți acești factori sunt importanţi și contribuie la evitarea accidentelor .

Aceste statistici însă iau în considerare starea medie a unui adult în cazul în care

6
acesta nu a consumat substanțe alterante sau se află într-o stare alterată . O
porțiune mare de accidente însă sunt cauzate exact din cauza faptului că omul se
află într-o astfel de stare , printre cele mai comune , intoxicația cu alcool și
starea de somnolență . În 2014 , 32% din accidentele din Statele Unite ale
Americii au fost cauzate de persoane care se aflau într-o stare de intoxicație cu
alcool . Aceste peirderi de viața ar putea fi evitate dacă mașinile ar fi echipate cu
sisteme care să poată detecta și preveni astfel de incidente , prin intervenția
directă asupra mașinii sau alertarea șoferului . [13]

Scopul acestei lucrări este de a prezenta câteva din abordările care ar

putea fi folosite pentru detectarea unor elemente care pot preveni aceste
accidente . Dintre aceste elemente care trebuie detectate mă voi concentra pe
detecţia pietonilor , a drumului , a semaforului , a altor vehicule de pe drum și a
semnului STOP . Aceste elemente le-am considerat elemente critice care pot
duce la prevenirea unui accident .

Detecţia se va realiza într-un mediu tridimensional simulat care constă din

elementele de mai sus , un vehicul care va primi comenzi de la utilizator și un
mediu tridimensional similar unui mediu urban .

2.STUDIUL ACTUAL AL APLICAŢIILOR EXISTENTE ÎN DOMENIU

Bazate pe tehnologii de senzori inteligenţi sistemele de asistenţă a

șoferului monitorizează constant ce se află în jurul vehiculelor precum și
comportamentul şoferului pentru a evita diverse pericole . În situații critice
sistemul poate avertiza sau poate interveni , în cazul în care pericolul este
iminent.

În ani recenţi s-au dezvoltat multe tehnologii pentru asistenţa șoferului și

fiecare producător de autovehicule încearcă să integreze aceste tipuri de
tehnologii în propriile modele . Acest domeniu este de prim interes pentru
companiile tehnologice și pentru cele care oferă servicii de transport .

Vehiculul trebuie constant să știe unde se află , să recunoască obiectele din

jurul acestuia și să calculeze ruta optimă . Aceste lucruri cer sisteme puternice de
recunoaștere vizuală care pot să combine date de la mai multe camere și senzori
în același timp , plus surse de navigație , plus calcularea rutei optime totul în
timp real .

7
2.1 NVIDIA DRIVE PX
O firmă care realizează cercetări în domeniu este nVIDIA prin platforma
DRIVE PX . Aceasta combină metode din domeniul deep learning şi fuziune a
senzorilor cu algoritmi din domeniul viziunii pe calculator. Această platformă este
capabilă să combine date de la 12 camere împreună cu lidar , radar şi senzori
ultrasonici ceea ce permite o imagine de 360 de grade în jurul vehiculului care
permite detectarea tuturor elementelor atât statice cât şi dinamice din jurul
vehiculului .[17]

Folosirea DNN (deep neural network) petru recunoaşterea şi clasificarea

obiectelor îi creşte foarte mult acurateţea . Drive PX conţine şi algoritmi avansaţi
din domeniul viziunii pe calculator care se ocupă de prelucrarea imaginii .
Platforma rulează pe două procesoare nVIDIA tegra x1 care au împreună 2.3
teraflopi . De asemenea , acest modul poate fi folosit în combinaţie cu platforma
Driveworks pentru a crea hărţi ale rutelor pe care a circulat maşina , cu scopul de
a oferi altor vehicule informaţii cu o acurateţe mai mare . Modulul menţine
constant o imagine de 360 de grade a vehiculului prin alipirea imaginilor primite
de la camerele de luat vederi plasate pe autovehicul .[17]

Fig.1. Detectarea elementelor pe platforma DRIVE PX [Sursa:http://www.nvidia.com/object/drive-px.html]

Fig.2. Vedere 360 de grade în jurul maşinii DRIVE PX [Sursa:http://www.nvidia.com/object/drive-px.html]

8
2.2.VEHICULUL AUTONOM DE LA GOOGLE

Un exemplu de vehicul fără pilot , complet autonom , este vehiculul de la

Google care are deja peste 300 000 km la bord şi care a fost testat atât pe
circuite speciale cât şi în diferite medii cum ar fi autostrăzi sau drumuri urbane .
Vehiculul foloseşte un dispozitiv Velodyne cu 64 de raze laser care
genereză un model 3d detaliat al mediului înconjurător . Apoi maşina combină
aceste hărţi cu unele preîncărcate în memorie . Vehiculul conţine şi alţi senzori
precum cele 4 radare , 2 în faţă şi 2 în spate care permit vehiculului să vadă la
distanță pe autostrăzi , pentru evitarea coliziunilor . Vehiculul are o cameră
montată pe oglinda retrovizoare de afară care detectează semafoarele , precum
şi GPS , o unitate de măsurare a inerţiei şi encodere la fiecare roată care
determină poziţia maşinii şi ţin cont de mişcarea acesteia .
Dezavantajul mare al acestui vehicul este faptul că se bazează foarte mult
pe hărţi deja create prin întregistrarea drumurilor dinainte de către un vehicul cu
operator uman . Aceste hărţi vor fi totuşi , în viitor , uşor accesibile precum şi de
precizie mare .[18]

Fig.3. Vehiculul autonom de la Google [Sursa:http://spectrum.ieee.org/automaton/robotics]

Fig.4. Maparea mediului [Sursa:http://spectrum.ieee.org/automaton/robotics]

9
2.3.SISTEMELE DE ASISTENŢĂ A ŞOFERULUI MOBILEYE

În mod tradiţional , producătorii auto au implementat soluţii de minimizare

a impactului colizunilor asupra şoferului şi a pasagerilor pe maşinile produse de
aceştia . Viitorul însă constă din sisteme de evitare a coliziunilor prin asistarea
şoferului cu date esențiale sau prin preluarea controlului temporar al vehiculului
în cazuri de urgenţă .

Compania MobilEye oferă două tipuri de sisteme de asistenţă a şoferului :

MobilEye 560 şi MobilEye Shield . Aceste sisteme au scopul de a recunoaşte alte
vehicule , pietoni , ciclişti , benzi , semne de circulaţie .

Fig.5. MobilEye 560 [Sursa:http://www.mobileye.com/products/]

Produsul MobilEye 560 este format dintr-o cameră care se montează pe

bordul maşinii şi care comunică cu aplicaţia special creată de pe smartphone-ul
şoferului . Facilităţile pe care le oferă sistemul includ : detectarea pietonilor şi a
bicicliştilor pe timp de zi , avertizare în cazul coliziunii cu vehicule aflate în faţă ,
pe autostrăzi şi în zone urbane inclusiv detecţia motocicletelor , avertizare în
cazul devierii de pe bandă , recunoaşterea semnelor de circulaţie şi furnizarea
șoferului informaţii despre drum şi elemente detectate în timp real .

Comunicarea între dispozitivul care înregistrează imaginea şi realizează

procesarea şi smartphone-ul utilizatorului se face prin Bluetooth . O facilitate
opţională este controlul luminilor maşinii dar acest lucru necesită instalarea unor
sisteme adiţionale . Acest sistem este compatibil cu orice tip de vehicul inclusiv
camioane , dube , autoturisme . Controlul luminilor însă este limitat la vehicule
care suportă acest lucru , aici fiind incluse majoritatea vehiculelor fabricate după
2011 . Componentele sistemului incluse în pachetul standard includ: o unitate
senzor echipată cu o cameră HDRC(High Dynamic Range) şi o placă de procesare

10
SeeQ2 dezvoltată de MobilEye pentru calcularea în timp real a transformatelor de
imagine necesare procesării video . De asemenea , sistemul vine cu un buzzer
pentru alertare audio precum şi un dispozitiv Eye Watch Display pe care sunt
afişate informaţii vizuale de avertizare .[19]

MobilEye Shield este destinat pentru camioane , autobuze şi alte vehicule

utilitare . Poate fi integrat pe orice tip de vehicul indiferent de cât de vechi este
modelul acestuia . Scopul acestui sistem este de mitigare a colizunilor iminente şi
este construit special pentru evitarea colizunii cu cei mai greu de observat
utilizatori ai drumului în cazul vehiculelor de dimensiuni mari : pietonii , cicliştii şi
motocicliştii . Aceştia de obicei sunt acoperiţi de corpul vehiculelor mari şi intră în
unghiurile moarte ale acestuia , sitemul având rolul de a-i detecta în aceste
zone , în care şoferul nu poate . [19]

Acest sistem conţine de asemenea şi majoritatea facilităţilor care se

întâlnesc şi pe sistemul MobilEye 560 cum ar fi : avertizarea în cazul coliziunilor
frontale , avertizarea în cazul părăsirii benzii , indicatori de limite ale vitezei ,
avertizări în cazul coliziunii cu pietoni sau ciclişti . De asemenea , sitemul este
echipat cu funcţionalităţi de telemetrie şi extrage date despre vehicul precum şi
istoricul acestor date care sunt transmise apoi unor siteme de managmentul
flotei . Din aceste date se pot extrage comportamentul şi performanţele zilnice
ale şoferului .

Acest tip de sistem pentru evitarea cicliştilor este instalat deja pe camioane
şi autobuze în districul Ealing al Londrei cu planuri de viitor pentru instalarea
acesor sisteme pe mijloace de transport în comun şi în alte districte .[19]

2.4.SISTEMELE DE ASISTENŢĂ A ŞOFERULUI PLK TECHNOLOGIES

Firma PLK TECHNOLOGIES cu sediul în Seoul , Coreea de Sud , oferă

sitemul OPTIAN pentru asistenţa şoferului în timp real . Funcţia principală a
acestui sistem este de a preveni coliziunea cu vehicule din faţa maşinii . Acest
lucru se realizează prin urmarirea maşinii din faţa şi calcularea potenţialului
coliziunii în funcţie de viteza relativă a maşinii şi distanța între maşina în care
este instalat sitemul şi vehiculul din faţă .

Când sistemul detectează pericolul unei coliziuni acesta alertează şoferul

printr-un set de alarme audio . De asemenea , sistemul conţine o componentă de
detectare a părăsirii benzii care alertează șoferul prin semnale audio când
vehiculul părăsește benzile , când acesta se află la o viteza mai mare decat cea
selectată din opţiuni .

11
Fig.6.OPTIAN [Sursa:www.hktdc.com/manufacturers-suppliers/PLK-Technologies-Co-Ltd/]

Sistemul monitorizează contiunuu traficul din faţa maşinii şi este capabil

să detecteze dacă vehiculele din faţa au pornit în cazul aşteptării la semafor .
Acest lucru ajută la prevenirea accidentelor când există congestii mari la
semafoare şi lumina se schimbă , alertând șoferul în cazul frânelor bruște sau
dacă mașinile din faţă au pornit , prin alerte audio . Camera din dotarea sitemului
înregistrează în permanență drumul şi salvează aceste date în memoria internă
astfel încât odată produs un accident aceste date pot fi consultate pentru
determinarea cauzei . Optional se poate instala şi o cameră în spatele vehiculul
pentru detectarea maşinilor care se apropie .[22]

2.5.SISTEME DE ASISTENŢĂ A ŞOFERULUI OFERITE DE LUXOFT

Fig.7.Concept al interfeţelor Luxoft [Sursa:http://www.luxoft.com/automotive/adas-computer-vision/]

Compania Luxoft oferă soluţii pentru asistenţa şoferului care funcţionează

împreună cu sistemele acestora de augumentare vizuală . Software-ul este
optimizat pentru sisteme embedded şi încorporează metode din inteligența
artificială , procesarea imaginii şi procesarea în timp real a semnalelor .
Compania oferă o gama largă de siteme printre care asistenţă avansată pentru
parcare , AAC (Adaptive Cruise Control) , siteme de menținere a benzilor ,
sisteme de monitorizare a şoferului . Sistemele comunică cu cele de augmentare

12
vizuală prin marcarea în timp real a obiectelor pe ecrane sau , în viitor , direct pe
parbrizul interactiv al vehiculului . Soluțiile software propuse de Luxoft
funcţionează pe diferite platforme bazate pe QNX , Linux , Android sau Windows .
[21]

Capacitățile de augmentare vizuală sunt compatibile cu o multitudine de

sisteme oferite pe piață precum LCD-uri şi Smartglass . Capacităţile sistemului
includ detectarea benzilor precum şi categorizarea acestora în cazul autostrăzilor
late , detectarea schimbarii benzilor , detectarea punctelor de interes precum
benzinării şi marcarea acestora pe ecranele disponibile şoferului , detectarea
coliziunilor , detectarea vitezei pe semnele de circulaţie , detecţia semaforului ,
detecţia accidentelor , planificarea rutei . Sistemul de asemenea transmite
informaţii telemetrice în cloud . Multe dintre aceste facilităţi sunt însă momentan
în faza de proiect şi nu sunt disponibile comercial .[21]

2.6.SOLUŢII OFERITE DE COMPANIA ITSEEZ

Firma Itseez oferă soluţii de asistare a şoferului pentru a îmbunătăți

siguranţa şi confortul acestuia în timpul condusului . Categoriile principale de
soluţii software care acestia le oferă sunt : avertizare în cazul părăsirii benzilor ,
detectarea semnelor de circulaţie , detecţia pietonilor , detecţia colizinuilor
frontale precum şi siteme de monitorizare a şoferului şi sisteme de controlul
stopurilor .

Detectarea semnelor de circulaţie este compatibilă doar cu semne de

circulaţie Europene şi din Statele Unite ale Americii . Avantajele acestui sitem
faţă de altele este că detectează semnele şi în zone obscure care au un contrast
slab al imaginii . Detectorul de benzi construieşte o reprezentare a spațiului
dintre benzi şi reacționează la modificarea acestui spaţiu , în acest fel detectând
schimbarea de bandă . Sistemul de evitarea a coliziunilor calculează distananța
între vehiculul din faţă şi vehiculul şoferului și avertizează în cazul în care acesta
se apropie prea tare . Sistemul de detecţie al pietonilor se bazează pe mișcarea
acestora prin compararea diferențelor între cadre capturate la momente de timp
diferite . [20]

Spre deosebire de alte firme Itseez oferă şi soluţii pentru monitorizarea în

timp real a şoferului . Sistemul lucrează cu imagini capturate de la o cameră de
pe bordul maşinii şi monitorizează constant faţa şoferului şi orientarea acesteia.
Sistemul este capabil să detecteze dacă șoferul adoarme la volan , nu este atent
sau este indispus pe moment . [20]

13
Fig.8.Soluţii de detecţie a pietonilor şi a semnelor de circulaţie oferite de itseez
[Sursa:http://itseez.com/products/]

Aceste sisteme folosesc OpenCV pentru detectare şi platforma

AcceleratedCV creată de Itseez pentru accelerarea functionalitatilor OpenCV , în
special pe platforma ARM . AcceleratedCV actionează ca un strat deasupra
OpenCV dar permite şi accesarea directă a funcţiilor Opencv . Această platformă
optimizează peste 60 de funcţii folosite în produsele comercial , care sunt critice
în detecţia rapidă a elementelor de pe drum .

Printre aceste funcţii sunt incluse : detectorul FAST , detectorul de colt

Harris , detectorul Canny , filtre de imbunatățire a imaginii (Blur , Scharr ,
Median Blur , Gaussian Blur ,Sobel) , filtre morfologice (Resize , Warp Perspective
, Warp Affine , Remap) .

Fig.9. Platforma AcceleratedCV [Sursa:http://itseez.com/products/]

2.7.CERCETĂRI REALIZATE DE MERL (MITSUBISHIELECTRIC

RESEARCH LABORATORY)

Deivizia de cercetări a companiei Mitsubishi electric lucrează la sisteme de

recunoaştere vizuală care extrag informaţie utilă din imagini şi se ocupa de o
gama variata de aplciatii ale acestor tipuri de siteme . Se doreste extragerea cat
mai multor informaţii din imagini şi categorizarea acestor informaţii în modele ale
mediului înconjurător .

14
 De exemplu , cercetătorii au creat algoritmi pentru extragerea zonelor de
interes din imagini şi clasificarea acestor regiuni sau obiecte în funcţie de un
element comun . Acest lucru premite de asemenea urmarirea obiectelor specifice
în imagini precum şi estimarea unei traiectorii a acestuia . Multe din proiecte se
concentrează pe analiza unor obiecte tridimensionle bazându-se pe imagini
bidimensionale cum ar fi estimarea pozitiei obiectelor şi recunoaşterea acestora .
[23]
Unul din proiectele realizate de aceștia a fost realizarea unei corelări a
poziției vehicului cu reprezentarea acesteia într-un model tridimensional al unui
oraș . Pentru a accelera realizarea calculelor cercetătorii s-au axat şi pe
imbunatatirea procesului de extratie a iamginilor acestea putand fi trecute prin
filtre direct în dispozitivele de achizitionare a imaginii înainte de a fi trecute prin
algoritmii de procesare vizuală . Aceste cercetări au aplicații în mai multe
domenii de la roboti industriali pană la aplicatii medicale . Cercetări în acest
domeniu au fost însă initiate pentru realizarea unui vehicul autonom sau pentru a
oferi sisteme de asistenţă a şoferului în viitoarele modele de autoturisme
realizate de Mitsubishi.[23]

Viitorul consta însă din sisteme de tip ITS (Intelligent Transportation

Systems) care sunt dezvoltate în multe ţări din Europa şi Statele Unite ale
Americii . Aceste tehnologii presupun comunicatia între vehicule inteligente şi
drumuri inteligente . Vehiculele comunică între ele printr-o interfată V2V sau prin
interfată V2I cu drumul .

3.DESCRIEREA SOLUŢIEI PROPUSE

3.1.ELEMENTE GENERALE

În cadrul acestei lucrări , voi prezenta un sistem de detectare a imaginilor

pentru un vehicul terestru . Mediul înconjurător , camerele de luat vederi precum
şi vehiculele vor fi simulate într-un mediu tridimensional . Vehiculul cu camerele
ataşate se va deplasa într-un mediu virtual special creat pentru a demonstra
capabilităţile de detecţie a elementelor de interes .
Proiectarea sistemelor de vedere pe calculator pentru vehicule este o
problemă complexă deoarece , de obicei , sunt necesare camere care
înregistrează imagini în mişcare , ceea ce face detectarea elementelor o
problemă complicată . Din aceste motiv precum şi faptul că algoritmii de viziune
pe calculator sunt computaţional intenşi este necesar ca sistemul să se bazeze pe
recunoaşterea unui numar fix de caracteristici . În acest fel am încercat să mă
concentrez pe elementele cu gradul cel mai mare de importanţă pentru evitarea
accidentelor .

15
 Elemente centrale care ar trebui luate în considerare includ:
- unde se află drumul sau marcaje de drum;
- detecţia altor vehicule care se află pe drum;
- unde se află pietonii;
- detecţia semnelor de circulaţie cele mai importante;
- detecţia semaforului.

O problemă importantă care se întâlneşte în mediul natural o reprezintă

calitatea imaginii în diverse condiţii meteorologice sau vizibilitate slabă precum şi
inconsistenţa drumurilor . De exemplu , un sistem contruit pentru navigarea în
oraş nu se descurcă dacă se schimbă tipul drumumului , cum ar fi cazul în care
intră pe drumuri de ţară , deoarece apare o schimbare de culoare sau de formă .
O altă problemă este schimbarea de perspectivă , drumurile nefiind mereu plate
sau drepte . Este posibilă găsirea unor transformate care să coincidă cu
perspectiva imaginii în diferite cazuri , dar acest lucru creşte considerabil
complexitatea problemei precum şi puterea de procesare necesară pentru
realizarea acestor lucruri .

O altă problemă este planificarea rutei , în acest caz trebuie să ne bazăm

foarte mult pe GPS , ajutat de algoritmii de recunoaştere . Pentru a rezolva
problema recunoașterii imaginilor în mişcare trebuie să ne limităm pe cazuri
separate . De exemplu , navigarea unui oraș , a unei autostrăzi , a drumurilor
accidentate , a drumurilor circulate de către pietoni mulţi .

În cadrul acestei lucrări , mă voi rezuma la o scenă urbană în care există

un drum asfaltat . De asemenea , fiindcă ne aflăm într-un mediu tridimensional ,
multe din considerentele ilustrate mai sus devin neglijabile . Putem mereu să ne
bazăm pe faptul că există un drum , care nu se schimbă . De asemenea , drumul
nu prezintă denivelari iar vehiculul nu vibrează , în acest fel acesta nu poate să
introducă perturbaţii sau zgomot în sistem , provenit de la dispozitivele de
intrare. . Luminozitatea va fi mereu consistentă şi uşor reglabilă , iar camerele
vor scoate mereu imagini clare ale mediului înconjurător .

Sistemul recunoaște o gama de obiecte care pot fi văzute de regulă din

interiorul unui vehicul : alte vehicule , pietoni , marcaje de circulaţie , semafor .
Viteza maşinii de asemenea va fi constantă însă aceasta poate fi modificată
oricând .Viteza mişcării deci poate fi în general ignorată şi putem să ne
concentrăm pe recunoaşterea de tipare .

Pentru realizarea acestei aplicaţii am folosit librăria OpenCV şi Motorul

Grafic Unity .

16
3.2.MOTORUL GRAFIC UNITY

Simularea mediului înconjurător şi a condiţiilor a fost realizată în Unity .

Unity este un motor grafic 3D dezvoltat de către Unity Technologies care a fost
lansat pe 8 Iunie 2005 . Motorul grafic este multiplaformă şi funcţionează pe mai
multe dispozitive precum PC-uri , console , telefoane mobile , tablete şi în
playerele web . Obiectivul iniţial al motorului grafic a fost de a permite
dezvoltarea jocurilor pe calculator dar poate fi extins şi pentru realizarea de
simulări sau în alte scopuri .

Motorul grafic foloseşte librăria Direct3D pentru a randa elementele

tridimensionale pe care le vede utilizatorul pe ecran în cazul în care este rulat pe
Windows sau pe Xbox360 şi OpenGL pentru Mac , tablete şi telefoane . [10]

Fig.10. Motorul Grafic Unity

Motorul grafic a fost ales datorită uşurinţei de utilizare şi capacitatea de a fi

programat din limbajul de programare C# precum şi pentru compatibilitatea cu o
serie mare de platforme în cazul în care se dorește extinderea aplicaţiei pe alte
paltforme . De asemenea , motorul grafic Unity este compatibil cu majoritatea
pachetelor de generare a modelelor tridimensionale şi poate schimba fişiere
foarte uşor cu acestea .

Interfaţarea între motorul grafic şi librăria OpenCV se face cu ajutorul

pachetului EmguCV care permite activarea funcţiilor definite în OpenCV folosind
limbajul C# .

17
 Motorul grafic Unity este alcatuit din două părţi principale : editorul 3D şi
editorul de cod . În editorul 3D se construieşte lumea tridimensională în care se
va desfăşura simularea precum şi setarea proprietăţilor acesteia precum
materiale , aspectul obiectelor care populează mediul şi ataşarea componenetelor
care dau funcţionalitatea . Modelele tridimensionale au fost realizate cu ajutorul
programului Blender , un pachet software care permite crearea de modele
tridimensionale şi animaţii .

Motorul grafic Unity este bazat pe obiecte , fiecare element din lumea
tridimensională fiind reprezentat de un obiect . Fiecare obiect are o serie de
parametri care pot fi observaţi în partea dreaptă a ecranului . Printre proprietăţi
se întâlnesc transformatele obiectelor tridimensionale , cum ar fi poziţie , locaţie
şi dimensiune , modelul folosit pentru calculul coliziunii şi materialul aplicat
modelului . Tot în această secţiune se ataşează şi script-urile care reprezintă
codul ce dă funcţionalitate simulării .

Programul care dă funcţionalitate este împarţit în mai multe fişiere care

sunt ataşate unei cameră care la randul ei este ataşată unui model tridimensional
al vehiculului . Clasele care constituie programul şi dau funcţionalitatea extind
clasa de bază MonoBehaviour conform standarelor de programare a motorului
grafic Unity aceasta fiind clasa de bază .

3.3. LIBRĂRIA OPENCV

Librăria OpenCV (Open Source Computer Vision) este o librărie software

dedicată viziunii pe calculator care a fost construită cu scopul de a fi o
infrastructură comună pentru aplicații din acest domeniu și pentru a accelera
folosirea percepţiei mașină în produse comerciale . A fost lansată sub licenţă BSD
în iunie 2000. [5]
Librăria conține peste 2500 de algoritmi optimizaţi , atât clasici cât și de
ultimă oră , din domeniul viziunii pe calculator . Aceşti algoritmi pot fi folosiți
pentru a recunoaște fete , identifica obiecte , clasifica acțiuni umane în video ,
pentru a urmări mișcarea camerei , a urmări obiecte care se mișcă în scenă etc.
librăria este folosită extensiv în grupuri de cercetări , de către agenții
guvernamentale și companii mari cum ar fi Google , Yahoo , Microsoft , Intel ,
IBM , Sony , Honda , Toyota precum și de companii mai mici precum Applied
Minds , VideoSurf , Zeitera .
Aplicaţiile în care sunt folosiți acești algoritmi variază de la legarea
imaginilor de stradă pentru a forma imagi panoramice mari , detectarea intruşilor
în sistemele de pază , monitorizarea echipamentului în minele din China ,
navigarea roboţilor , detectarea acidentelor în piscine , rularea artei interactive ,
verificarea pistelor de aterizare pentru defecțiuni , recunoaştere facială . [5]

18
 Librăria poate fi utilizată în urmatoarele limbaje de programare : C++ , C ,
Python , Java și poate fi integrată cu MATLAB . LIBRăRIA ruleaza pe Windows ,
Linux , Android , MacOS . Se poate folosi de de instrucțiuni de tip MMX și SSE
dacă procesorul pe care rulează suportă aceste facilităţi , precum și interfețe
pentru CUDA de la nVidia sau OpenCL de la AMD . Aceste facilităţi nu sunt
folosite în lucrarea curentă . Deoarece motorul grafic Unity permite programarea
doar în C# iar librăria OpenCV nu suportă acest limbaj de programare trebuie să
apelăm la o interfață între limbajul C# și OpenCV . Din acest motiv am folosit
adițional și librăria EmguCV . [5]

3.4.LIBRĂRIA EMGUCV

Librăria EmguCV este o interfaţă (wrapper) între OpenCV și pachetul .Net

de la Microsoft ceea ce permite funcţiilor din OpenCV să fie invocate din limbaje
compatibile cu pachetul .Net cum ar fi : C# , Visual Basic , Visual C++ ,
IronPython etc. Pachetul EmguCV poate fi compilat de către Visual Studio ,
Xamarin Studio(MonoDevelop) și Unity și poate rula pe Windows , Linux ,
MaxOSX , iOS , Android , Windows Phone .[13]
Variabilele de bază pe care le voi folosi în această lucrare sunt Mat care
este o structură de tip matrice ce conține pixelii din imagine precum și informații
despre culoare și canale , precum și structura de tip Image<Bgr,Byte> care este
tot o reprezentare a unei imagini similară cu structura Mat . Folosim aceste două
structuri deoarece anumite funcții acceptă doar un singur tip de variabilă la
intrare , conversia între cele două însă se poate face foarte ușor prin folosirea
metodelor ToMat() , ToImage<Bgra,Byte>().
Un exemplu de creare a unei imagini este următorul:
1. Mat img=new Mat(640,480,DepthType.Cv8U,3)

Această linie de cod creează o imagine de 64 pixeli pe orizontală și 480

pixeli pe verticală cu 3 canale , fiecare canal reprezentând o culoare roșu , verde
sau albastru , fiecare canal având 8 biţi per canal ceea ce înseamnă 256 de valori
posibile pentru fiecare canal . Invocarea funcţiilor din OpenCV se realizează de
regulă prin funcţia CvInvoke urmată de funcţia din OpenCV și parametrii
adecvaţi.
De exemplu pentru încărcarea imaginilor din fişiere :
1. Mat img=CvInvoke.Imread(„exemplu.jpg”);

În cazul structurii Image<Bgr,Byte> , bgr reprezintă tipul de culoare în

cazul de faţa albastru , verde , roșu și Byte numarul de biţi per canal . Tipurile de
culori suportate includ : Gray (pt imagini în tonuri de gri) , BGR , BGRA , HSV ,
HLS , LAB , LUV , XYZ , YCC și adâncimile de culoare : BYTE , SBYTE , Single ,

19
Double , UINT16 , INT16 , INT32 .
O altă metodă de încărcare a imaginilor și cea mai des folosită în această
lucrare este:
1. Image<Bgr,Byte> img=new Image<Bgr,Byte>(„exemplu.jpg”) ;

3.5.STRUCTURA APLICAŢIEI

Simularea este alcătuită dintr-un drum drept pe care circulă un vehicul la o

viteză constantă stabilită la începutul pornirii simulării . Vehiculul are ataşat două
camere pe partea din faţă a acestuia . Prima cameră are rolul de a captura şi
reda imaginile pentru utilizator , astfel încât acesta să aibă o vedere în spaţiul
tridimensional . Motorul Unity , de asemenea , are nevoie de o cameră principală
refuzând să afişeze imagini în absenţa acesteia . Cea de-a doua cameră
înregistrează efectiv mediul tridimensional şi îl stochează într-o structură de date
de tipul RenderTexture .

Pe masură ce vehiculul se deplasează de-a lungul drumului acesta trebuie

să recunoască drumul , pietonul care se mișcă în faţa maşinii , celelate vehicule
de pe drum , semnul de circulaţie stop şi semaforul .

Programele care se ocupă de detecţia fiecarui element sunt ataşate celei

de-a doua camere care înregistrează scena . Fiecare program salvează imaginea
cu zona special marcată în memoria locală .

Pentru a simplifica accesul la funcţii importante şi pentru a pastra structura

orientată pe obiecte a motorului grafic Unity , precum şi pentru a permite fiecarui
program de detecţie să fie ataşat separat în funcţie de nevoie am creat o clasă
Detector de bază pe care o moştenesc toate celelalte clase care realizează
detecţia unui anumit element . Clasa Detector conţine funcţii de bază care sunt
necesare în algoritmii de detecţie .
De asemenea , am folosit o clasă specială pentru capturarea imaginilor de
la cea de-a doua cameră care se ocupă decat cu salvarea unei imagini originale
pe care celelate programe decât o încarcă și o procesează .

Primul pas al programului este importarea pacheteleor de care ne vom

folosi .

1. using UnityEngine;

UnityEngine conţine toate funcţiile care ţin de motorul grafic Unity cum ar
fi structuri de date care reprezintă obiectele din spațiul tridimensional și funcții
care permit modificarea stării acestora .

20
 1. using System.Collections;

System.Collections conţine structura de date de tip listă care va fi folosită

pentru stocările elementelor detectate.

1. using Emgu.CV;
2. using Emgu.CV.Util;
3. using Emgu.CV.UI;
4. using Emgu.CV.CvEnum;
5. using Emgu.CV.Structure;

Aceste librării conţin structurile de date şi funcţiile necesare pentru

funcţionarea EmguCV .

1. using System.Runtime.InteropServices;
2. using System;
3. using System.Drawing;

Aceste librării conțin structurile de bază pentru funcţionarea limbajului C#

precum şi reprezentări ale primitivelor grafice precum pătrate , linii şi alte forme
geometrice necesare .

1. using System.IO;

Această librărie conţine funcţiile de manipulare a fişierelor care permit

scrierea datelor in memoria locală .

1. public class CapturareTextura : MonoBehaviour {

Clasa care capturează textura extinde MonoBehaviour , clasa de bază a

motorului grafic Unity .Acest lucru permite atașarea acestia unui obiect din cadrul
mediului tridimensional . În acest caz , această funcţie va fi ataşată camerei care
înregistrează imaginea pentru buna funcționare a metodei OnPostRender().

1. public RenderTexture rendtex=null;

2. public Texture2D textura=null;

Variabilele de bază care sunt folosite , RenderTexture şi Texture2D , conţin

imaginile care vor fi salvate în fişier extrase din motorul grafic . Una din camerele
montate pe vehicul exportă toate imaginile capturate unei variabile de tip
RenderTexture .

1.public void Start() {

2.RenderTexture.active = rendtex;
3.textura = new Texture2D (rendtex.width,rendtex.height); }

Funcţia Start() permite iniţializarea variabilelor atunci când obiectul este

21
creat , de obicei la pornirea simulatorului . Pentru camera la care va fi ataşat
scriptul este necesar specificarea structurii de tip RenderTexture de care să se
folosească ceea ce se face prin proprietatea RenderTexture.active .Această
structură este optimizată pentru a stoca imaginile preluate în timp real de către o
cameră . Apoi trebuie creată o nouă structură de tip Texture2D de dimensiunile
rendtex pentru a putea stoca pixelii din aceasta .

1.public void CaptureazaTextura(){

2.textura.ReadPixels(new Rect(0,0,rendtex.width,rendtex.height),0,0);
3.textura.Apply ();
4.byte[] rawImage =textura.EncodeToJPG();
5.File.WriteAllBytes(Application.dataPath+"/img_orig.jpg",rawImage); }

Funcţia de capturare a texturii extrage imaginea de la cameră şi o salvează

într-un fişier în format jpg . În primul rând trebuie transferaţi pixelii de la textura
de randare într-o nouă textură care a fost creată în funcţia Start , prin apelarea
metodei ReadPixels . Aceasta citeşte toți pixelii de la coordonatele (0,0) pană la
coordonatele maxime care corespund dimensiunilor texturii de randare . Ultimii
parametri ai funcţiei reprezintă un decalaj pe care îl păstram la (0,0) deoarece ne
interesează toată imaginea . Apoi se creează un vector de biţi care va stoca
imaginea codată în format JPG , acest lucru se face prin metodă EncodeToJPG()
aplicată texturii . Ultimul pas este reprezentat de scrierea acestor biţi într-o
locaţie din memoria locală .

1.public class Detector : MonoBehaviour {

Clasa detector moşteneşte clasa de bază a motorului grafic Unity ,

MonoBehaviour , ceea ce ne permite folosirea funcţiilor start , update şi
OnPostRender care sunt esențiale funcţionării corespunzatoare a aplicaţiei şi de
care avem nevoie în celelalte clase .

1.public void SalveazaImagine(Image<Bgr,Byte> img,string nume){

2. try {
3. img.Save (Application.dataPath + nume);
4. }catch(Exception Ex) {Debug.Log (Ex.ToString());}}

Funcţia acceptă o imagine la intrare şi locul unde să salveze imaginea .

Rolul funcţiei este de a salva imagini în memoria locală după aplicarea procesarii
şi este înconjurată de un bloc try catch în caz că nu este posibilă accesarea
locului specific de pe memoria locală .

1.public Image<Bgr,Byte> IncarcaImagine(String nume){

2. try {
3. Image<Bgr,Byte> img=new Image<Bgr, Byte>(Application.dataPath +
nume);
4. return img;

22
 5. }catch(Exception Ex) {
6. Debug.Log (Ex.ToString ());
7. return null;}}
Funcţia de încărcare a imaginii returnează imaginea citită de pe memoria
locală şi accepta ca intrare numele locaţiei în format string . Încarcarea imaginii
este înconjurată de un bloc try catch care depistează dacă există imaginea în
memoria calculatorului .

1.public virtual Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte> img)

2. {return null;}

Funcţia de procesare este declarată în funcţia de bază pentru a putea fi

înlocuită în funcţiile urmatoare care o extind din acest motiv este declarată
virtual . Funcţia accepta la intrare o imagine care trebuie procesată şi returnează
rezultatul tot sub forma de imagine .

3.6.TRANSFORMAREA ÎN IMAGINI CU TONURI DE GRI

1.public UMat aplicaGrayscale(Image<Bgr,Byte> img)

2.{ UMat gray = new UMat ();
3. CvInvoke.CvtColor (img, gray, ColorConversion.Bgr2Gray);
4. return gray;}

Funcţia transformă imaginea color primită la intrare într-o imagine în tonuri

de gri . O imagine digitală în tonuri de gri (Greyscale) este o imagine în care
valoarea fiecărui pixel conține doar intensitatea luminii nu și informaţii despre
culoare . Imaginile de acest fel, de asemenea cunoscute sub numele de imagini
alb-negru , sunt compuse exclusiv din nuanţe de gri , variind de la cea mai slabă
intensitate , negru , la cea mai puternica , alb .

Imaginile în tonuri de gri sunt diferite de imaginile alb-negru bitonale , care

conțin decât valorile maxime de intensitate ale imaginii , reprezentate de două
culori , negru și alb .

Imagini în tonuri de gri sunt adesea rezultatul de măsurare a intensității

luminii la fiecare pixel într-o singură bandă a spectrului electromagnetic . Dar, de
asemenea , ele pot fi sintetizate din imagini color cum este în cazul de faţă .

Intensitatea unui pixel este exprimată într-un anumit interval între un

minim și un maxim, inclusive. Această gamă de intensităţi este reprezentată într-
un mod abstract ca un interval de la 0 (absența totală, negru) și 1 (prezența
totală, alb), cu valori fracţionale între .

23
 În reprezentarea digitală a imaginilor , pixelii sunt stocaţi în format binar,
cuantificaţi . Imaginile în tonuri de gri destinate pentru afișare vizuală sunt
stocate cu 8 biți per pixel , ceea ce permite 256 intensități diferite .
Reprezentările binare presupun că 0 este negru și valoarea maximă 255 la 8 BPP
(bit per pixel)este de culoare albă . Precizia oferită de acest format este abia
suficientă pentru a evita artefactele , dar foarte convenabilă pentru programare,
deoarece un singur pixel ocupă apoi un singur octet.[1]

Pentru a converti o culoare dintr-un spațiu bazat pe un model RGB într-o

reprezentare în tonuri de gri , trebuie calculate sumele ponderate . Valoarea
pixelului se calculează ca sumă ponderată a trei valori intensitate liniare. Spaţiul
de culoare sRGB este definit în termeni de luminanță liniară Y , care este dat de :

Y=0.21R+0.71G+0.07B

Coeficienții R,G,B reprezintă valorile culorilor roșu ,verde, albastru .[1]

3.7.EXTRAGEREA CONTURURILOR FOLOSIND ALGORITMUL CANNY

1. public UMat aplicaCanny(Image<Bgr,Byte> img,double

Canny_thresh,double Canny_threshL)
2. { UMat contururi = new UMat ();
3. UMat image = aplicaGrayscale (img);
4. CvInvoke.Canny (image, contururi,
Canny_thresh,Canny_threshL);
5. return contururi;}

Rolul acestei funcţii este de a aplica algoritmul de detecţie Canny care

extrage contururile dintr-o imagine . Acesta a fost dezvoltat de către John F.
Canny în 1986. Canny a constatat că , cerințele de aplicare a detectarii
marginilor pe diverse sisteme de viziune sunt relativ aceleași .

Criteriile generale impuse pentru detectarea de margini în imagini digitale

includ:

- Detectarea cu rata de eroare scăzută, ceea ce înseamnă că detectarea ar

prinde cu exactitate mare cât mai multe margini din imagine ;
- Punctul de margine detectat de către operator trebuie localizat exact pe
centrul marginii ;
- O anumită margine din imagine trebuie să fie marcată doar o singură
dată, și în cazul în care este posibil, zgomotul de imagine nu ar trebui să creeze
margini false.

Pentru a satisface aceste cerințe Canny a folosit calculul variațiilor , o

24
tehnică care găsește o funcție care optimizează un anumit funcțional . Printre
metodele de detectare a marginilor dezvoltate până în prezent, algoritmul de
detectare a marginilor Canny este una dintre cele mai strict definite metode care
oferă o detecție cu o acurateţe bună . Datorită optimalităţii de a întruni cele trei
criterii de detectare margine și simplităţii procesului de punere în aplicare , este
unul dintre cei mai populari algoritmi pentru detectarea de margine , motiv
pentru care a fost ales și pentru această lucrare . Pe lângă acestea librăria
OpenCV conține o implementare optimizată pentru viteză de procesare cât mai
mare .

Din moment ce toate rezultatele de detectare a marginilor sunt ușor

afectate de zgomot de imagine , este esențial folosirea unui filtru de tip netezire
Gaussiană pentru a filtra zgomotul și a preveni detectările false .

Detectarea marginii se realizează prin analiza gradientului între pixelii

vecini . O margine într-o imagine poate indica într-o varietate de direcții, astfel
încât algoritmul Canny foloseşte patru filtre pentru a detecta marginile orizontale,
verticale și diagonale din imagine. Operatorul de detectare margine returnează o
valoare pentru primul derivat în direcția orizontală (Gx) și direcția verticală (Gy).
Din acest gradient de margine se poate stabili direcția:

√
G= G2x +G2y
Θ=atan 2(G x , G y )

Unghiul de direcție margine se rotunjește la una din cele patru unghiuri

reprezentând verticală, orizontală și două diagonale (0 °, 45 °, 90 ° și 135 °, de
exemplu). O direcție margine care se încadrează în fiecare regiune de culoare va
fi setat la o valoare specifică unghiului, de exemplu, alfa situată în regiunea
galben (0 ° la 22,5 ° și 157,5 ° la 180 °) va fi setată la 0 °.[1]
Suprimarea non-maximală se aplică la "subțierea" de margine. După
aplicarea calculelor marginea extrasă din valoarea gradientului este încă destul
de neclară. Astfel, această metodă poate ajuta pentru a suprima toate valorile
gradient la 0 cu excepția maximului local , ceea ce indică locația cu cea mai clară
schimbare a valorii intensitate. [1]

Procedura aplicată pentru fiecare pixel din imagine este:

- Comparația puterii marginii pixelului curent cu puterea marginii pixelului
în direcțiile pozitive și negative de gradient;
- Dacă puterea marginii pixelului curent este cea mai mare comparativ cu
ceilalţi pixeli din aceeași direcție (adică, pixelul care este îndreptat în direcția y,
acesta va fi comparat cu pixelul de deasupra și dedesubtul acesteia pe axa
verticală), valoarea va fi păstrată. Altfel, valoarea va fi suprimată.[1]

25
 După aplicarea suprimarii non-maxim, pixelii de margine sunt destul de
aproape de marginea reală. Cu toate acestea, există încă unii pixeli margine în
acest moment cauzaţi de zgomot și variație de culoare. Pentru a scăpa de
răspunsurile false , este esențial filtrarea pixelului margine cu valoarea
gradientului slabă . Astfel două valori prag sunt setate la clarificarea diferitelor
tipuri de pixeli de margine, unul este numit valoare prag ridicată , iar celălalt se
numește valoarea prag scăzut . Dacă valoarea gradientului pixelului marginea
este mai mare decât valoarea de prag ridicată , aceştia sunt marcaţi că pixeli
puternici de margine. Dacă valoarea gradientului pixelului margine este mai mică
decât valoarea de prag mare și mai mare decât valoarea de prag scăzut, ele sunt
marcate că pixeli margine slabi. Dacă valoarea pixelilor este mai mică decât
valoarea de prag scăzut, aceştia vor fi suprimaţi . Cele două valori de prag sunt
valori determinate empiric, care vor trebui să fie definite atunci când se aplică la
imagini diferite . Aceste limite sunt date funcției prin variabilele canny_thresh și
canny_threshL . [1]

3.8.FILTRUL DE TIP NETEZIRE GAUSSIANĀ

1. public UMat aplicaGaussianBlur(UMat img,int kernel_gauss)

2. { UMat blur = new UMat ();
3. CvInvoke.GaussianBlur (img, blur, new Size (kernel_gauss,
kernel_gauss), 0, 0);
4. return blur; }

În procesarea imaginii, o un filtru de tip Gaussian blur (de asemenea

cunoscut că netezire gaussiană) este rezultatul estompării unei imagini printr-o
funcție Gauss. Acesta este un efect utilizat pe scară largă în multe pachete
software grafice , de obicei, pentru a reduce zgomotul de imagine și de a reduce
detaliile .
Efectul vizual al acestei tehnici este asemănător cu vizualizarea imaginii
printr-o sită translucidă . Netezirea Gaussiană este, de asemenea, utilizată în
etapele de pre-procesare din algoritmi ai vederii artificiale , cu scopul de a spori
acuratetea detecţiei .

Cu toate că am precizat la începutul capitolului că datorită faptului că

imaginile digitale pe care le folosim sunt capturate dintr-un simulator nu avem
zgomot în imagine , folosim filtrul de tip netezire gaussiană pentru a evidenţia
zonele care conţin elementele structurale importante .

Filtrul de netezire gaussiană este un tip de filtru de imagine care utilizează

o funcție Gauss pentru calcularea transformării care să se aplice fiecarui pixel din
imagine. Ecuația unei funcții gaussiane într-o singură dimensiune este:

26
 2
x
−
1 2

G(x)= e 2σ
√2π σ
În spațiul bidimensional este produsul a două astfel de funcții gaussiene una
pentru fiecare dimensiune:

2 2
x +y
−
1 2σ
2

G(x)= e
√2π σ
unde x este distanța de la origine în axa orizontală, y este distanța de la origine
în axa verticală, și σ este abaterea standard a distribuției Gauss. Atunci când
este aplicat în două dimensiuni, această formulă produce o suprafață a cărei
contururi sunt cercuri concentrice cu o distribuție Gaussiană din punctul central.
Valorile acestei distribuții sunt utilizate pentru a construi o matrice de convoluție
care se aplică imaginii originale. Valoarea noua a fiecarui pixel este setat la o
medie ponderată a pixelilor vecini . Valoarea pixelului original primește cea mai
mare pondere și pixelii vecini primesc ponderi mai mici în funcție creşterea
distanței de la pixelii originali . [1]

De obicei, un program de procesare a imaginii trebuie să calculeze numai o

matrice cu dimensiuni [6σ]x[6σ], pentru a asigura un rezultat suficient de
aproape de cel obținut când am folosi întreaga distribuție gaussiană .
Dimensiunea matricii este dată de variabila kernel_gauss .[1]

Netezirea Gaussiană este frecvent utilizată împreună cu detecția

marginilor. Cei mai mulţi algoritmi de detectare a margini sunt sensibili la
zgomot. Folosind un filtru netezire Gaussiană înainte de detectarea conturului are
că scop reducerea nivelului de zgomot în imagine, care îmbunătățește rezultatul
algoritmului de detectare Canny .

3.9.FILTRUL DE TIP THRESHOLDING

1. public Image<Bgr,Byte> aplicaThreshhold(Image<Bgr,Byte> img,double

limita,double limita_max) {
2. UMat thres_img = new UMat ();
3. UMat gray = aplicaGrayscale (img);
4. CvInvoke.Threshold (gray, thres_img, limita, limita_max,
ThresholdType.Binary);
5. return thres_img.ToImage<Bgr,Byte> (); }

Metoda Thresholding este cea mai simplă metodă de segmentare a

imaginii. Dintr-o imagine în tonuri de gri , folosind un filtru de tip thresholding
obținem imagini binare care conţin doar două tonuri alb și negru.

27
 Cele mai simple metode de thresholding înlocuiesc fiecare pixel dintr-o
imagine cu un pixel negru în cazul în care intensitatea de imagine I{i, j} este mai
mică decât o constantă fixă T ( I{i, j} <T ) , sau un pixel alb dacă intensitatea
imaginii este mai mare decât constanta T . Constanta este dată de variabila
limita.

Metodele de thresholding se categorizează în următoarele șase grupe, pe

baza informațiilor pe care le manipulează algoritmul :
- Metode bazate pe forma histogramei, în cazul în care, de exemplu,
vârfurile, văile și curburilor histogramei sunt analizate;
- Metodele bazate pe clusterizare, unde nivelele de gri sunt grupate în
două părți, după cum lcoatia inc are se află:fundal sau prim plan ;
- Metode bazate pe entropie ceea ce conduce la algoritmi care folosesc
entropia regiunilor din prim-plan și de fundal;
- Metode bazate pe legatura Atribut-Obiect ce presupun căutarea unei
măsuri de similitudine între nivelul de gri și imaginile binarizate, cum ar fi
similitudini între forme neclare, coincidența marginilor, etc.;
-Metodele spațiale care folosesc distribuția de probabilități sau de corelatii
între pixeli;
- Metode locale care adapteaza valoarea de prag pe fiecare pixel la
caracteristicile locale ale imaginii. În aceste metode, un alt T este selectat pentru
fiecare pixel din imagine.[5]

Metoda de treshholding folosită în această lucrare este cea mai simplă din
metodele exprimate mai sus . Algoritmul analizează în imagine fiecare pixel și îl
compară cu o valoarea predidefinită . Dacă este mai mică pixelul ste înlocuit cu
negru , dacă este mai mare acesta este înlocuit cu valoarea maximă data de
variabila limita_max , în cazul acesta 255 adică alb complet.

3.10.RECUNOAŞTEREA DRUMULUI

Indiferent de scopul sistemului , recunoaşterea drumului este o etapă

importantă deoarece recunoaşterea obiectelor depinde foarte mult de extracţia
drumului . De asemenea , concentrarea pe detecţia obiectelor care se află decat
pe suprafata drumului şi eliminarea informaţiei din imagine care nu îl conţin
poate ajuta la scaderea nivelului de complexitate a problemei precum şi la
scaderea numarului de resurse necesare .

Nivelul de iluminare al drumului influențează cel mai mult detecţia acestuia

deorece anumite zone de drum pot fi iluminate mai puţin sau mai mult decât
altele ceea ce duce la goluri în detecţia drumului , recunoaşterea parţială sau
includerea părților care nu corespund . În cazul de faţa , simulatorul randează o

28
scenă într-un mediu urban iar iluminarea poate fi modificată uşor . De
asemenea , mă voi concentra pe detecţia limitelor drumului şi a marcajului
central din centrul drumului .

Abordarea aleasă în prezenta lucrare este detectarea liniilor folosind

transformată Hough . Această metodă presupune trecerea imaginii mai intâi
printr-un filtru Greyscale pentru a elimina în totalitate culoarea din imagine .
După aceea se aplică filtrul Canny pentru a scoate contururile obiectelor din
imagine . Pe această imagine care conţine contururile se aplică transfomata
Hough care încearcă să extragă liniile . Rezultatele sunt variabile în funcţie de
multitudinea de obiecte drepte care se regasesc în imagine şi în funcţie de
parametrii care sunt daţi funcţiei , cum ar fi lungimea aproximativă a liniilor care
trebuie să le gasească , lungimea maximă a găurilor între segmente de linie .

Scopul metodei este de a găsi instanţe imperfecte ale unor obiecte într-o
anumita clasa de elemente printr-o procedură bazată pe vot . procedură de
votare se face pe o instanţă de obiecte deja extrase din imagine din care se aleg
candidaţii şi un spaţiu acumulator creat de algoritm pentru calcularea
transformatei Hough .

Iniţial metoda a fost creată pentru a detecta decât liniile dintr-o imagine ,
dar revizii multiple asupra formulelor inţiale au extins această metodă şi altor
forme geometrice precum cercuri şi elipse . În această lucrare , voi folosi
transformata Hough doar pentru detecţia liniilor . Transformata Hough folosită
astăzi în recunoaşterea imaginilor a fost inventată de către Richard Duda şi Peter
Hart în 1972 care au denumit-o atunci versiunea generalizată a transformatei lui
Hough după ideile iniţiale publicate de către Paul Hough în 1962 . [1]

Metoda a câștigat prestigiu în cadrul domeniului de vedere pe calculator

odată cu folosirea acesteia cu success de către Dana H. Ballard în 1981, a carui
cercetări au fost publicate în articolul cu titlul "Generalizing the Hough transform
to detect arbitrary shapes". [1]

În cele mai multe cazuri , imaginea iniţială este trecută printr-un algortim
Canny inainte pentru a obţinem contururile care sunt stocate separat că o
mulţime de coordonate de puncte sau pixeli din imagine . Implementarea
transformatei Hough în OpenCV accepta la intrare doar multimi de puncte care
constituie contururi extrase deja , deci aplicarea filtrului Canny înainte este un
pas obligatoriu . Datorită imperfecţiilor din imaginea originală sau a imperfecţiilor
contururilor detectate de algoritm pot aparea întreruperi în contururi sau puncte
lipsă din curbele care le alcatuiesc pe acestea în funcţie de zgomotele din
imagine la care a fost supus algortimul . [1]

29
 Scopul transformatei Hough este de a adresa aceată problemă prin
facilitarea grupării acestor puncte în categoria adecvată . Aceasta analizează
mulţimea de puncte extrase în fazele de detecţia conturului printr-o procedură de
votare . Cel mai simplu caz este detecţia liniilor . O linie dreaptă are ecuaţia
y=mx+b care poate fi reprezentată că un punct (b,m) . Liniile verticale pot
deveni problematice deoarece dau valori parametrului m care pot ieşi din limitele
alocate . Astfel Duda şi Hart au propus folosirea formei normale a lui Hesse din
motive de resurse computaţionale . În acest caz , r reprezintă distanţa de la
origine către cel mai apropiat punct al liniei drepte şi θ unghiul dintre axa x şi
linia care conectează originea cu cel mai apropiat punct .[1]

Din acest motiv , este posibilă asocierea fiecarei linii dintr-o imagine a unei
grupări (r,θ) . Planul în care sunt valabile acest tip de coordonate poartă
denumirea de spaţiu Hough . Dat fiind un singur punct în acest plan atunci toate
liniile drepte care trec prin acel punct corespund unei sinusoide în planul (r,θ)
care este unică acestui punct . Un set de două sau mai multe puncte care produc
o linie dreaptă creează sinusoide care se intalnesc în planul (r,θ) pentru acea
linie. În acest fel problema detectării punctelor coliniare poate fi convertită în
problema găsirii unor curbe concurente .[1]

Algortimul care foloseşte transformată Hough utilizează o mulţime

bidimensională numită acumulator pentru a detecta existenta unei linii descrisă
de formula : r = xcos θ + y sin θ . Dimensiunea multimii accumulator este egală
cu numarul parametrilor necunoscuți adică 2 în cazul formulei de mai sus r şi θ .
Pentru fiecare pixel aflat la coordonata (x,y) şi în jurul acesteia transformată
Hough determină dacă există suficiente dovezi (prin procesul de votare) care să
demonstreze că există o linie dreaptă care corespunde pixelului . dacă da , va
calcula parametrii (r,θ) ai acelei linii şi va cauta în acumulator dacă parametrii se
încadrează.Dacă da , acumulatorul va fi incrementat . Prin găsirea acumulatorilor
cu cea mai mare valoarea cautând , de regulă , maximul din spaţiul acumulator ,
liniile cu cea mai mare probabilitate vor fi extrase şi forma lor geometrică poate fi
dedusă . [1]

Cea mai simpla metodă de detectare a acestor vârfuri este reprezentată de

folosirea unor metode de tip thresholding dar în funcţie de caz alte metode pot
da rezultate mai bune şi pot scoate mai multe linii din imagine . Liniile care sunt
extrase nu conțin însă şi informaţii despre lungime , de aceea este nevoie de
proceduri adiţionale , în pasul urmator , pentru a stabili care linie corespunde în
ce locaţie . Din cauza erorilor de la pasul de detecţie a contururilor vor fi erori în
spaţiul acumulatorilor ceea ce complică găsirea vârfurilor şi deci a liniilor . [1]

Rezultatul final este o mulţime bidimensională de coordonate (r,θ) . Fiecare

punct din mulţime are o valoare egală cu suma punctelor sau a pixeleleor care se

30
află pe linia corespunzatoare . Deci elementul cu cea mai mare valoare indică
linia dreaptă .

1. public class DetectorBenzi : Detector {

Clasa de detecţie a marginilor drumului extinde clasa Detector creată

anterior pentru acessul la funcţii de încărcare şi salvare a imaginilor precum şi
acces rapid la anumite filtre .

1. void Update()
2. {
3. imagine = IncarcaImagine ("/Resources/img_orig.jpg");
4. imagine = Proceseaza (imagine);
5. SalveazaImagine (imagine,"/Resources/drum.jpg");
6. }

Funcţia Update realizează operaţiile după terminarea randării scenei de

către motorul grafic . în cadrul acestei funcţii se realizează încărcarea imaginii ,
procesarea acesteia precum şi salvarea în memoria locală . Pentru detecţia
drumului pornim de la premiza că vehiculul se află mereu pe un drum , din
moment ce scena reprezintă un mediu urban . De asemenea , putem face
presupunerea că acesta se va află mereu sub linia orizontului deci putem defini
un dreptunghi care să contină doar jumatatea de jos a imaginii originale .
Detecţia liniilor se va realiza doar în această zona . Acest lucru elimină şi
eventuale linii detectate pe blocuri sau alte semne care pot apărea în distanță .

1. UMat Contururi = aplicaCanny (img,Canny_thresh,Canny_threshL);

2. LineSegment2D[] linii = CvInvoke.HoughLinesP (
Contururi,
rho,
theta,
limita,
minLungimeLinie,
minDistanta );
Funcţia de procesare returnează o imagine care conţine liniile detectate şi
acceptă ca intrare o imagine . Primul pas în detectarea imaginii este reprezentat
de aplicarea unui filtru Canny cu parametrii 100 şi 50 astfel încât să obţinem
doar contururile . Al doilea pas este reprezentat de extragerea punctelor care au
fost detecate că linii în funcţie de parametrii daţi . Liniile sunt stocate într-o
matrice de elemente LineSegment2D . Al treilea pas este reprezentat de
marcarea liniilor în imaginea iniţială , pentru acest lucru se parcurge matricea de
linii şi se desenează fiecare linie peste imaginea inţială . Funcţia de desenare se
aplică imaginii inţiale şi acepta că parametri liniile descoperite , culoarea acestora
şi grosimea lor . De asemenea , pentru a elimina o parte din liniile orizontale care
nu sunt de interes vom calcula unghiul format de linia detectată şi o linie dreaptă
verticală . Dacă linia formează un unghi între 80 şi 90 de grade cu linia verticală

31
această poate fi eliminată . De asemenea , am ales culori diferite pentru a
delimita liniile din dreaptă sau stânga scenei . Algoritmul ia fiecare linie şi verifică
dacă punctele acesteia sunt incluse într-un dreptunghi care conţine decat pixelii
din dreapta imaginii . Dacă punctele sunt în dreapta atunci linia va fi desemnată
cu o altă culoare , în acest caz verde .

Fig.11.Stagiile de procesare pentru marcarea drumului : imagine originală (dreapta) , aplicare filtru
Canny(sus), algoritmul Hough(jos)

3.11.RECUNOAŞTEREA SEMNULUI DE DE CIRCULAŢIE STOP

Procesul de analiză imaginii îl extindem spre detectarea elementelor din

mediul înconjurător vehiculului şi ne concentrăm asupra semnelor de circulaţie .
Datorită complexităţii detectării gamei largi de semne de circulaţie disponibile
trebuie să ne limităm asupra detecţiei unei game mici de semne . De asemenea ,
detectarea semnelor de circulaţie este facută d de faptul că acestea pot fi diferite
în funcţie de ce ţară sau pe ce continet ne aflăm . Am ales ca detecţia să se
concentreze pe semnul STOP doarece acesta are importanţa cea mai mare când
vine vorba de evitarea accidentelor .

Abordarea aleasă în această lucrare este reprezentată de analiza imaginilor

după culoare . Fiecare categorie de semne de circulaţie are o culoare
caracteristică , de exemplu , semnul de stop are culoarea roşie , semnul pentru
atenţionare în cazul unei treceri de pietoni este albastru .

Similar cu restul funcţiilor de detectare şi acest program va extinde clasa

32
de bază Detector . Încarcarea şi procesarea imaginilor se vor face tot în funcţia
Update după randarea completă a imaginii .

1. void Update()
2. {imagine = IncarcaImagine ("/Resources/img_orig.jpg");
3. imagine = Proceseaza (imagine);
4. SalveazaImagine (imagine,"/Resources/semn_stop.jpg");}

După cum am stabilit detecţia se va face după culoare , ceea ce înseamnă

că ne uitam în imaginea originală după nuanţe de roşu aprins . Funcţia care
realizează procesarea imaginii acceptă la intrare imagini în format RGB şi
returnează tot o imagine RGB cu zonele de interes marcate cu cercuri .

1. public override Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte> img)

Pentru a putea detecta nuanţa de roşu trebuie transformată imaginea din

spaţiul BGR(Albastru , Verde , roşu) , în care este încărcată , într-un spaţiu HSV
(Hue , Saturation , Value ) .

Am pornit de la premiza că semnul de circulaţie care ne interesează se va

afla mereu în partea dreaptă a imaginii deci putem să ignoram jumatea stangă .
Acest lucru se face prin definirea unui dreptunchi care conţine decat pixelii din
dreapta imaginii .

1. img.ROI = new Rectangle (img.Width/2,0,img.Width/2,img.Height);

Conversia în spaţiul de culori HSV se face folosind functia CvtColor . După

convertirea imaginii definim 2 matrici în care vom extrage 2 canale din imagine .
Canalele pe care le vom extrage contin informaţii despre nuanţă (hue) şi
saturatie (Saturation) .

1. Mat channel1 = new Mat();

2. Mat channel2 = new Mat();
3. CvInvoke.ExtractChannel(hsv, channel1, 0);
4. CvInvoke.ExtractChannel(hsv, channel2, 1);

Apoi voi defini două limite în care se încadrează naunta roşie cautată . Pe
spectrul nuanțelor culoarea roşie se află în jurul valorii 20 şi peste valoarea 160 .
Apoi voi trece prin toți pixelii matricii care conţine valorile nauntei şi voi extrage
decat pe cei care corespund valorilor stabilite .

1. ScalarArray lower = new ScalarArray(limita_joasa) ;

2. ScalarArray upper = new ScalarArray(limita_inalta) ;
3. CvInvoke.InRange(channel1, lower, upper, channel1);

33
 Zonelor de culoare apoi li se va aplica un filtru thresholding pentru a
obţine o delimitare mai bună a acestora precum şi pentru a obţine date mai bune
la aplicarea filtrului Canny care va scoate toate contururile din imaginea
prelucrată .

1. CvInvoke.Threshold(channel2,channel2, 10, 255, ThresholdType.Binary);

2. Canny = aplicaCanny (channel1.ToImage<Bgr,Byte> (), Canny_thresh,
Canny_threshL);

Aceste contururi vor fi aproximate cu cercuri care vor fi marcate în

imaginea iniţială .

1. foreach (CircleF cerc în listaCercuri) {

2. img.Draw (cerc, new Bgr (System.Drawing.Color.Green), 2);

Fig.12. Stagiile de procesare a imaginii : imaginea originală , extracţia culorii, filtrul Canny si marcarea pe
imaginea inţială

3.12.RECUNOAŞTEREA ALTOR VEHICULE

În ani recenți s-au dezvoltat diverse metode pentru localizarea vehiculelor

pe drum pentru sistemele de asistenţă a şoferului sau pentru mașinile
autonome . Cele mai utilizate metode presupun montarea de senzori infraroșii
sau radare pe partea frontală a maşinilor şi detectarea obiectelor din față .
Aceste metode dau cele mai bune rezultate .

Abordarea aleasă în această lucrare se bazează însă pe recunoaşterea

maşinilor doar din imaginile capturate de la cameră . Pentru a realiza acest lucru
am incercat să extrag masinile după colarea acestora . Abordarea este similara
cu detecţia semnului stop de circulaţie .

34
 O prima ipoteza de la care pornim este că vehiculele se vor afla mereu pe
drum . Drumul este mereu aflat în partea de jos a imaginii şi ne interesează
decat vehiculele de pe drum care sunt la o distanta medie faţa de vehiculul care
conţine camera . Astfel că am definit o zonă care să conțină decat pixelii de la
jumatatea imaginii în jos . Acest lucru simplifică detecţia vehiculelor precum şi
elimină eventuale zone eronate detectate deasupra drumului .

Mai intai trebuie să convertim imaginea din spaţiul BGR în spațiul HSV ,
după care se extrag primele două canale care dau nuanţa şi saturația imaginii .
Urmatorul pas este reprezentat de alegerea limitelor de culoare după care să se
uite funcțiile . Deoarece gama de culori în care sunt disponibile vehiculele din
ziua de astazi este foarte mare şi nu putem lua toate aceste variatii separat , mă
voi concentra pe 3 culori de bază : roşu , albastru , verde . Acest lucru
presupune trecerea de 3 ori prin filtrul de culoare .

1. ScalarArray lower = new ScalarArray(limite[0]) ;

2. ScalarArray upper = new ScalarArray(limita_inalta) ;
3. CvInvoke.InRange(channel2, lower, upper, channel2);

Odata obtinute cele 3 imagini pentru fiecare culoare luată în considerare

vom extrage contururile folosind metodă Canny .

1. List<RotatedRect> listaDreptunghi = new List<RotatedRect> ();

2. VectorOfVectorOfPoint contururi = new VectorOfVectorOfPoint ();
3. CvInvoke.FindContours (Canny,
4. contururi,null,
5. RetrType.List,
6. ChainApproxMethod.ChainApproxSimple,
7. default(Point));

Din contururile care sunt obtinute sunt selectate doar cele neîntrerupte .
După extragerea conturilor programul încearcă aproximarea acestor contururi cu
dreptunghiuri şi calculează aria acestora .

1. for (int i = 0; i < nrContururi; i++) {

2. VectorOfPoint contur = contururi [i];
3. VectorOfPoint conturAproximat = new VectorOfPoint ();
4. CvInvoke.ApproxPolyDP (contur,
5. conturAproximat,
6. 5,
7. true);

Acestor dreptunghiuri li se calculează aria pentru a stabili dacă sunt

suficient de mari pentru a reprezenta vehicule . Dacă mașinile se intersectează
cu alte obiecte contururile pot aparea prea mari sau pot fi întrerupte şi astfel nu
se iau în calcul .

35
 1.if(CvInvoke.ContourArea (conturAproximat, false) > arie) {
2.listaDreptunghi.Add (CvInvoke.MinAreaRect
(conturAproximat));}

Ultimul pas constă în marcarea acestor dreptunghiuri pe imaginea iniţială .

1. foreach (RotatedRect dreptunghi în listaDreptunghi) {

2. img.Draw (dreptunghi, new Bgr (System.Drawing.Color.Green), 2);

Fig.13. Stagiile de detectare a maşinilor : imagine originală (stanga sus) , extracţia culorii (dreapta
sus) , aplicarea filtrului Canny (dreapta jos) , marcarea vehiculelor (dreapta jos) (detecţiile pentru cele 3 culori
au fost combinate intr-o singura imagine)

3.13.RECUNOAŞTEREA PIETONILOR

Teoretic pentru a localiza oamenii în imagini ne trebuie imagini anterioare

stocate în memorie cu diverse profile , deoarece oamenii au o gama largă de
forme sau culori diferite . O abordare de genul acesta ar necesita foarte multe
resurse computaţionale de aceea trebuie să ne limităm la bucăţi mai mici
separate.

Putem astfel să ne concentrăm pe marimea şi forma zonelor corpului care

se aseamană mai mult cum ar fi mâinile , picioarele , capul . Picioarele oamenilor
în mişcare pot fi detectate cu o matriță de tip U întors dar această metodă are
precizie mică .

36
O altă abordare o reprezintă cautarea oamenilor după pigmentaţia pielii . Această
abordare depinde foarte mult de distanţa persoanelor faţă de cameră deoarece la
distanţe mari şi rezoluţii mici zona feţei sau a mainilor , de unde poate fi extrasă
pigmentaţia pielii , nu este suficient de mare pentru a permite o detecţie
adecvată .

Pentru a mari precizia acestui tip de detecţie trebuie să folosim reţele

neurale , antrenând sistemul pe mai multe imagini selectate înainte de a face
detecţia . Procesul de antrenare poate fi compromis de prezenţa nisipului , a
pietrelor sau a construcţiilor de culoare crem sau roz . Aceste metode , de
asemenea se concentrează pe detecţia persoanelor de culoare alba şi nu iau în
considerare pe cei de alte culori . Avem deci nevoie de seturi în plus de antrenare
şi pentru persoanele de culoare diferită .

Un alt factor de luat în considerare este că sistemele vizuale nu au timp

suficient pentru a acumula suficiente date de antrenare deorece se află în
mişcare . La acest lucru se adaugă vizibilitatea scazuta în funcţie de condiţiile de
lumină sau cele de vreme nefavorabile . Aceste metode sunt mai degrabă
adecvate pentru sisteme de supraveghere care sunt statice şi au garantate
condiţii de iluminare mult mai bune .

În cazul detecţiei pietonilor trebuie luat în considerare că aceştia , de

obicei, traversează în grupuri mari în zonele special demarcate . În funcţie de
situaţie , acest lucru poate simplifica sau complica detecţia deoarece nu toti
respecta zonele special demarcate pe unde se treverseaza . De asemenea , când
este un grup mare de pietoni distincţia indivizilor devine destul de grea şi
Datorită faptului că au o varietate de culori ale îmbracămintei sau trasportă
anumite obiecte care pot duce la confuzii din partea sistemului . În cadrul acestei
lucrări m-am axat pe detecţia unui singur pieton care va trece strada .

Algoritmul HOG(History Of Gradients) este abordarea aleasă în acestă

lucrare . Metoda este bună pentru imagini de rezoluţie mai mică . Cu cât creşte
rezoluţia imaginilor , cresc exponențial resursele computaţionale necesare .
Metoda HOG are un alt avantaj în faptul că poate fi uşor adaptată pentru imagini
infraroşii deoarece lumina vizibila şi cea infraroşie creează siluete similare . În
cadrul acestei lucrări însă am lucrat cu imagini normale , nu în spectrul
infraroșu .
Metoda numară de câte ori apar orientari ale gradientului în porţiuni
localizate ale imaginii şi a fost descrisă pentru prima oară de către Navneet Dalal
şi Bill Triggs , cercetători ai Institutului National de Cercetări Francez în Domeniul
Automatizărilor şi al Ştiinţei Calculatoarelor ( INRIA ) , la Conferinţa pe teme de
Viziune pe Calculator şi recunoaştere a Tiparelor ( CVPR ) din 2005 . În această
prezentare ei s-au concetrat pe detectarea pietonilor în imagini statice , însă de

37
atunci s-au dezvoltat îmbunătăţiri ale metodei pentru detecţia oamenilor şi în
imagini video precum şi o gama largă de animale şi vehicule . [1]

Teoria esenţială din spatele acestei metode este că aspectul obiectelor şi

forma lor poate fi descrisă de distribuţii ale gradientului de intensităţi . Imaginea
este împarţită în zone mici conectate numite celule iar pentru fiecare pixel din
celula se creează o histograma a direcţiei gradientului . Metoda concatenează
apoi aceste histograme . Pentru acurateţe mai mare histograma locală poate fi
normalizată pentru a compensa pentru diferenţele de iluminare şi umbre .
Metoda HOG are anumite avantaje asupra altor metode . Deoarece lucrează pe
celule mici este invariantă la schimbări photometrice sau geometrice care pot
aparea în cazul unor imagini video . În cazul detecţiei pietonilor , aceată metodă
nu ţine cont de felul mişcării oamenilor ci de faptul că aceştia menţin de regulă
poziţia dreaptă în mişcare . Acesta este un avantaj mare în cazul detecţiei
oamenilor în imagini dar are performanţe mai slabe în cazul detecţiei animaleleor
sau a altor vehicule de pe drum . [1]

Fig.14.Recunoasterea persoanelor de catre algoritmul HOG

Primul pas este asigurarea unor valori ale culorii normalizate . Algoritmul HOG se
ocupă de acest fapt , deci nu este nevoie de alte etape de preprocesare.
Urmeaza calcularea valorilor gradientului . Urmatorul pas este reprezentat de
crearea histogramei celulelor . Fiecare pixel are o valoare corespunzatoare bazat
pe valori găsite în crearea gradientului . Celule pot fi rectagulare sau circulare ca
forma iar canalele hitogramei sunt răspândite între valori 0-180 sau 0-360 .
Pentru a compensa pentru diferente de iluminare şi contrast , gradientul trebuie
normalizat ceea ce necesită gruparea celuleror în blocuri interconectate .
Rezultatul final este concatenarea vectorilor de componente normalizate ale

38
histogramei celulelor . Aceste blocuri de obicei se suprapun ceea ce duce la faptul
că fiecare celulă contribuie de mai multe ori la rezultatul final . De regulă , există
două tipuri de blocuri : blocri rectangulare ( bloc R-HOG ) şi blocuri circulare
(bloc C-HOG). [1]
Blocuri R-HOG sunt în general patrate reprezentate de 3 parametri :
numarul de celule per bloc , numarul de pixeli per celulă , şi numarul de canale
per celulă a histogramei . În testele realizate de Dalal şi Triggs pentru detecţia
oamenilor paramtrii optimali erau patru celule de 8x8 pixeli per bloc şi 9 canale .
[1]

Blocurile C-HOG sunt descrise cu 4 parametri : numarul de valori radiale şi

angulare , raza zonei centrale , şi un factor de expansiune . Împarţirea imaginii
în blocuri circulare C-HOG nu dă rezultate foarte bune pentru detecţia
oamenilor . Pentru a îmbunătăţi algoritmul putem folosi metode din domeniul
retelelor neurale . Rezultatul descriptorului HOG poate fi folosit ca valoare de
intrarea pentru o reţea de tipul clasificator SVM ( Support Vector Machine ) .
Operatorul SVM este un clasificator binar care se uita după un hiperlan că funcţie
de decizie . Acesta trebuie antrenat pe imagini care contin obiectele pe care le
cautam în imagini . În cazul acestei lucrări LIBRăRIA OpenCV conţine deja
reteaua cu datele de antrenare deja stabilite .[1]

Implementarea algoritmului HOG în OpenCV are opţiuni special alese

pentru detecţia pietonilor . Acuratetea algoritmului este foarte buna dar viteza de
procesare a acestuia este detul de inceata mai ales pe imagini cu rezolutii mari .
Algoritmul însă nu a fost testat şi pe pietoni de alte culori acesta funcţionând cu
performanţe ridicate în cazul persoanelor de culoare albă .

Funcţia de detectare a pietonilor extinde funcţia de bază Detector iar

procesarea se realizează în cadrul funcţiei Update la fel că şi în cazul celorlate
programe de detecţie .

1. MCvObjectDetection[] regiuni;
2. HOGDescriptor DescriptorHOG = new HOGDescriptor ()
3. DescriptorHOG.SetSVMDetector(HOGDescriptor.GetDefaultPeopleDetector
());

Funcţia de detectare a pietonilor acceptă o imagine la intrare şi returnează

o imaginea cu zonele de interes marcate . În primul rand vom declara o matrice
de regiuni de tipul generic MCVObjectDetection . Librăria OpenCV conţine deja
algoritmul HOG optimizat pentru detecţia pietonilor . Acesta este accesat prin
obiectul HOGDescriptor , pe care il instanţiem . Apoi acestui obiect îi setăm tipul
de detecţie pe care vrem să il facem . În cazul acesta , vrem să detecăm
pietonii . Acest lucru se setează prin SetSVMDetector .

39
 1.regiuni=DescriptorHOG.DetectMultiScale(img,0,default(Size),
default(Size),1.05,2,false);

Apoi se aplică acest detector imaginii cu opţiunile din fabrică deoarece

aceastea sunt special ales pentru detecţia optimă a pietonilor .

1. foreach (MCvObjectDetection regiune în regiuni) {

2. img.Draw (regiune.Rect, new Bgr (System.Drawing.Color.Green), 1);

Ultimul pas este reprezentat de marcarea unor dreptunghiuri în jurul

regiunilor detectate .

Fig.15. Recunoaşterea pietonului

3.14.RECUNOAŞTEREA SEMAFORULUI

Recunoaşterea luminii rosii de la semafor este de asmenea un aspect

important . Acesta este un factor care poate duce la prevenirea accidentelor prin
intrarea neregulamentară într-o intersecţie .

În cadrul acestei lucrări , am considerat că este important ca vehiculul să

detecteze lumina roşie precum şi cea galbenă şi să atenționeaze șoferul în cazul
apariției oricăreia .

Abordarea folosită este similară detecţiei semnului stop . În principal ne

uitam după intensitatea luminii roşu sau galben de la stop . Nuanțele sunt
apropiate ca valoare de aceea le vom lua împreună . Pentru a putea detecta
nuanțele de roşu şi galben trebuie transformată imaginea din spaţiul BGR în care
este încărcată într-un spaţiu HSV .

40
 Similar programului pentru detecţia semnului stop am pornit de la premiza
că semaforul care ne interesează se va află mereu în partea dreaptă a imaginii
deci putem să ignoram jumatea stangă . Acest lucru se face prin definirea unui
dreptunchi care conţine decat pixelii din dreaptă imaginii . Conversia în spaţiul de
culori HSV se face folosind functia CvtColor .

1. img.ROI = new Rectangle (img.Width/2,0,img.Width/2,img.Height);

2. CvInvoke.CvtColor(img, hsv, ColorConversion.Bgr2Hsv);

După convertirea imaginii definim 2 matrici în care vom extrage 2 canale

din imagine . Canalele pe care le vom extrage conţin informaţii despre nuanţa
(hue) şi saturaţie (Saturation) .

1. Mat channel1 = new Mat();

2. Mat channel2 = new Mat();
3. CvInvoke.ExtractChannel(hsv, channel1, 0);
4. CvInvoke.ExtractChannel(hsv, channel2, 1);

Apoi vom defini două limite în care se încadrează naunţele cautate . Pe

spectrul nuanţelor culoarea roşie se află în jurul valorii 20 şi peste valoarea 160 .
Apoi vom trece prin toţi pixelii matricii care conţin valorile şi vom extrage decat
pe cei care corespund valorilor stabilite .

1. ScalarArray lower = new ScalarArray(limita_joasa) ;

2. ScalarArray upper = new ScalarArray(limita_inalta) ;
3. CvInvoke.InRange(channel1, lower, upper, channel1);

Zonelor de culoare apoi li se va aplica un filtru thresholding pentru a

obţine o delimitare mai bună a acestora precum şi pentru a obţine date mai bune
când aplicăm filtrul Canny care va scoate toate contururile din imaginea
prelucrată .

1. CvInvoke.Threshold(channel2,channel2, 10, 255,

ThresholdType.Binary);
2. Canny = aplicaCanny (channel1.ToImage<Bgr,Byte> (),
Canny_thresh, Canny_threshL);

Aceste contururi vor fi aproximate cu cercuri care vor fi marcate în

imaginea iniţială .

1. foreach (CircleF cerc în listaCercuri) {

2. img.Draw (cerc, new Bgr (System.Drawing.Color.Green), 2);

41
Fig.16. Stagiile de procesare pentru recunoaşterea semaforului

3.15.CONTROLUL MAŞINII

Reprezentarea tridimensională a maşinii pe care sunt ataşate camerele se

deplasează în cadrul simulării , în funcţie de recepţia comenzilor de la utilizator .
La începutul simulării , aceasta aşteaptă comanda de a porni în faţa .

1. private Transform myTransform;

2. public bool ruleaza=false;
3. public float viteza =0.5f;
4. public string direcţie="faţa";
5. public bool manual=false;
6. public float limita=2000;

Programul care controlează maşina trebuie întâi să primească o structură

de tip transformate pentru a şti ce transformate va manipula în timpul
funcţionării programului . Fiecare obiect tridimensional din cadrul motorului grafic
Unity are coordonate pe 3 axe notate cu X, Y ,Z acestea reprezentand
transformatele de poziţie .

În cadrul funcţionării programului , funcţia va incrementa sau decrementa

aceste valori pentru a muta obiectul dintr-o poziţie în altă . Deoarece camerele
sunt ataşate pe acest obiect , acestea vor copia incrementările şi decremetările
de poziţie de la obiectul maşină . Structura programului va fi ciclica , acesta va

42
repeta verificarea variabilei ruleaza pentru a determină dacă maşina trebuie să
se deplaseze sau să stea pe loc . Pentru a se deplasa coordonatele vor fi
înmulţite cu o variabilă care conţine viteza . Direcţia va fi selectată în funcţie de o
denumire . Variabila manual este pentru a putea da comanda de ignorare funcţiei
de frânare automată iar limita reprezintă aria minimă a obiectului detectat peste
care va frâna automat .

1. void Start () {
2. myTransform = this.transform;
3. ruleaza = false; }

În iniţializarea programului se va specifica faptul că vrem să folosim

transformatele obiectului la care este ataşat programul şi fatul că atunci când
simularea porneşte vehiculul trebuie să stea pe loc şi să aştepte comanda de la
utilizator .

Funcţia Update este folosită la terminarea de randare a fiecarui cadru . În

cadrul acestei funcţii se fac verificările diferitelor variabile declarate mai sus .

1. void Update () {
2. if (Input.GetKeyUp ("w")) {
3. ruleaza = !ruleaza;
4. direcţie = "faţa"; }
5. if (Input.GetKeyUp ("s")) {
6. ruleaza = !ruleaza;
7. direcţie = "Spate";
8. if (Input.GetKeyUp ("m")) {
9. manual = !manual;}

Blocurile " if " verifică dacă utilizatorul a apăsat unul din butoanele
corespunzatoare şi modifică variabilele în funcţie de comandă , în cazul de faţă
modificând direcţia şi oprind maşină .

1. public void mişcare(string direction,float speed)

2. { switch(direction){
3. case "Fata":
4. myTransform.position += Vector3.forward * speed;
5. break;
6. case "Spate":
7. myTransform.position-=Vector3.forward*speed;
8. break;
9. } }

Funcţia de mişcare citeşte direcţia şi viteza şi realizează incrementarea

coordonatelor cu valorile corespunzatoare în funcţie de ce viteză a fost stabilită .

43
 1. public void setViteza(float arie)
2. {
3. if (manual != true) {
4. if (arie > limita) {
5. viteza = 0.0f;
6. } }
7. }

Funcţia de setare a vitezei este mereu apelată din funcţiile de detectarea a

elementelor . Rolul ei este de a frâna vehiculului în cazul apropierii prea mari a
acestuia de elementul detectat .

3.16.REZULTATELE SIMULĂRII

În cadrul simulării vehiculul se deplasează de-a lungul unui drum într-un

mediu tridimensional urban , iar în calea lui apar obiectele care trebuie
detectate : pietonul , semnul de criculatie stop , semaforul şi alte vehicule .

Din cauza structurii programului acesta rulează cu viteză mică , în jurul a

16 cadre pe secundă. Viteza scazută este datorată faptului că programul scrie şi
citeşte imagini constant în memoria locală . Această abordare nu a putut fi
evitată din cauza incopatibilităţii directe între LIBRăRIA OpenCV care lucrează cu
imagini în formatele comune precum JPEG , PNG şi Motorul Grafic Unity care de
regulă lucrează cu texturi . Pentru a castiga performanţă în mod normal toate
imaginile sunt încarcate la începutul pornirii aplicaţiei realizată în motorul grafic
Unity şi acestea nu se schimbă pe parcursul rulării aplicaţiei .

Datorită fatului că dorim procesarea în timp real a imaginilor acest lucru nu

a fost posibil , motiv pentru care am ales această abordare de a scrie şi citi
imaginile la fiecare pas de randare . Algoritmii de procesare a imaginilor de
asemenea cer putere de procesare foarte mare ceea ce duce la scaderea
numarului de cadre pe secundă care le poate afişa motorul . De asemenea ,
calculatorul pe care este rulată simularea influentează foarte mult performanţa .
Din cauza acestei limitări a performanţei nu se poate realiza detecţia tuturor
elementelor în acelaşi timp dacă vrem să obţinem o imagine cursivă .

Detecţia elementelor de interes variază foarte mult în funcţie de condiţiile

de iluminare ale scenei . În cazul iluminarii pe timp de zi algoritmii au rezultate
bune după cum au fost prezentate în secţiunile separate pentru fiecare element .
Am realizat şi testarea algoritmilor pe condiţii de ceaţă cu lumina slabă . Această
schimbare influenţează cu mult detecţia elementelor din imagine .

44
Fig.17. Detecţia elementelor in condiţii slabe de iluminare şi ceaţă

Detecţia drumului rămâne cea la care se pastrează acurateţea cea

mai mare . Scăderea limitei de vizibilitate duce la scăderea lungimii liniilor
detectate . În cazul detecţiei pietonului acurateţea scade foarte mult , algoritmul
detectând liniile albe al drumului dar acest lucru ii permite frânarea înainte de
ciocnirea cu pietonul . Detecţia slabă se datorează şi faptului că pietonul poartă o
geacă albă care , în condiţii de ceaţă se aseamana foarte mult cu fundalul .
Detecţia semnului stop are acurateţea mai mică dar cu modificarea parametrilor
de culoare aceasta se poate realiza , maşina reuşind să franeze înainte de
trecerea pe langă acesta . Acurateţea se modifică din cauză că se pierde din
nuanţa aprinsă de roşu a semnului stop când acesta este blocat de ceaţă . De
asemenea , detecţia semaforului suferă din aceleaşi cauze , culorile sunt
modificate şi acurateţea detecţiei suferă . Cea mai mare schimbare apare în

45
cazul maşinilor care nu mai sunt detectate aproape deloc . Prezenţa ceţei
introduce artefacte în detectarea contururilor , acestea aparând întrerupte şi deci
nu mai sunt luate în considerare .

În concluzie , programul funcţionează optim în condiţiile de iluminare

clară , similar iluminarii din timpul zilei , în absenţa altor elemente meteorologice
perturbatoare .

4.CONCLUZII

Realizarea unui sistem de navigare a unui vehicul folosind metode de

vedere pe calculator este o problemă dificilă din cauza a foarte mulţi factori care
trebuie luati în considerare .

Metodele matematice pentru realizarea recunoașterii şi extracţiei de

obiecte din imagine au fost create în anii 1970-1980 însă aceştia necesită resurse
computaţionale foarte mari pentru a putea fi puşi în practică . Din acest motiv ,
domeniul viziunii pe calculator s-a dezvoltat mult în perioada curentă . În acest
moment dispunem de procesoare suficient de puternice pentru a putea folosi
aceşti algoritm în timpi rezonabili .

Cu toate acestea tot trebuie să ne concentram pe anumite obiecte sau să

elminam zone ale imaginii care nu prezintă interes . De asemenea , camerele
moderne pot captura imagini la rezolutii foarte mari de ordinul milioanelor de
pixeli . Pentru a putea parcurge aceste imagini de mai multe ori într-un timp
adecvat este nevoie de foarte multe resurse computaţionale .

Aceste probleme afectează imaginile statice dar pentru un sistem de

recunoaştere realizat pentru un vehicul trebuie luat în considerare că acesta
înregistrează în timp real ceea ce creşte iar foarte mult complexitatea problemei .
Din aceste motive , se lucrează cu imagini de rezoluţii mai mici sau eliminam
canale de culoare din imagine . Acest lucru necesită trecerea imaginilor printr-o
serie de filtre înainte de aplicarea algoritmilor prezentaţi în această lucrare .
Filtrul cel mai folosit este filtrul Greyscale prin care se elimina culoarea din
imagine . În cazul unui sistem de detecţie pentru vehicule ne concentrăm pe
anumite elemente care pot fi extrase din imagine şi care au o importanţă foarte
mare pentru navigare . Aceste elemente sunt : Drumul şi marcajele de pe
acesta , Semnele de circulaţie cele mai importante, Alte vehicule care se gasesc
pe drum, Oamenii care traversează drumul .

În această lucrare m-am concentrat pe prezentarea unor metode simple

care pot fi implementate uşor dar care pot oferi performanţe destul de bune în

46
situaţia aleasă . Deoarece detectarea obiectelor folosind doar imagini capturate
de la camere care înregistrează în lumina naturală este foarte complexă şi este
foarte influenţată de mediul în care se află vehiculul precum şi de factori din
natura cum ar fi conditiile atmosferice şi timpul zilei , m-am concentrat pe un
mediu urban . De asemenea , ma-m concentrat pe detecţia obiectele care le-am
considerat cele mai importante pentru un vehicul aflat pe drum : limitele
drumului , pietonii , semnul de circulaţie stop , semaforul şi alte vehicule aflate
pe drum .

Mediul înconjurător am ales să fie unul tridimensional deorece în cadrul

acestuia se pot modifica mulţi parametrii iar alţi factori pot fi neglijaţi . Mediul
tridimensional nu este influenţat de vibraţii şi randează mereu imaginile la o
calitate precizată .

Pentru a da programului posibilităţi de portare uşoară pe alte platforme am

ales folosirea librăriei OpenCV care conţine mulţi algoritmi de prelucrare a
imaginii şi care a oferit o bază de cod de la care să pornesc . Librăria OpenCV
poate fi rulată pe o multitudine de platforme ceea ce fac metodele şi programele
prezentate în această lucrare extensibile , acestea putand fi portaţi pe alte
sisteme de operare precum Linux şi Android sau pot fi adaptaţi în alte limbaje de
programare suportate de Librăria OpenCV cu uşurinţă .

Simularea mediului tridimensional am realizat-o în motorul grafic Unity

deoarece acesta este compatibil cu o gama largă de paltforme , este intuitiv şi
are compatibilitate mare cu cele mai populare pachete software de realizare ale
modelelor tridimensionale . În cazul de faţă importarea modelelor din pachetul
software Blender realizăndu-se foarte uşor . Legatura între OpenCV şi Unity este
realizată de EmguCV .

Pentru detecţia drumului am ales să ma concentrez pe limitele drumului .

Detecţia acestora am realizat-o folosind algoritmul Hough . Acesta extrage liniile
care le gaseşte în imagine care apoi le-am categorizat în fucntie de locul în care
apar . Cu toate că liniile sunt detectate acestea nu sunt luate în considerare
pentru calcularea vitezei sau direcţiei vehiculului . O direcţie de viitor este
reprezentată de calcularea locatiei autovehiculului în raport cu benzile detectate .
De asemenea , programul presupune mereu că drumul este drept şi nu este în
stare să detecteze curbura drumului . O altă abordare de viitor este reprezentată
de includerea a două camere care fiecare detectează benzile inc are se
încadrează vehiculul şi incearca să il mentina în aceste limite .

În cazul detecţiei semnulul de circulaţie STOP am ales că detecţia acestuia

să se facă după culoare . Pentru o detecţie mai sofisticată se pot folosi filtre
aditionale aplicate zonei roşii detectate . De exemplu , semnul stop are literele

47
STOP marcate mare pe el putem folosi un algoritm de detecţie al literelor sau un
algortim de detecţie şi comparaţie a colţurilor extrase din imagine semnului şi
compararea acestora cu o imagine standard din memoria locală . Deoarece
detecţia după culoare este sensibilă , programul poate detecta şi alte semne de
ciculaţie predominat roşii ca fiind semnul stop .

Detectarea semaforului foloseşte o abordare similară cu cea ilustrată în

cazul semnului stop . Programul verifică tot nuanţele de culoare pentru a extrage
zona roşie din imagine dar în acest caz am luat în considerare şi zona galbena că
semnalănd interzicerea trecerii . Ca şi în cazul detecţiei semnului de circulaţie
există posibilitatea că programul să confunde culorile cu ale altor obiecte .

Detecţia altor autovehicule se bazeaza tot pe delimitarea în funcţie de

culoare . În cazul acesta ne reducem la anumite nuanţe . Detectarea însă nu
încadrează masinile foarte bine în pasul aproximaţiei cu dreptunghiuri . De
asemenea performantele scad dacă avem multe maşini în aceeasi scenă .

48
5.ANEXE

5.1.ANEXA 1 CLASA CAPTURARE TEXTURA

1. public class CapturareTextura : MonoBehaviour {

2. public RenderTexture rendtex=null;
3. public Texture2D textura=null;
4. public void Start(){
5. RenderTexture.active = rendtex;
6. textura = new Texture2D (rendtex.width,rendtex.height);
7. }
8. void OnPostRender()
9. { CaptureazaTextura (); }
10. public void CaptureazaTextura()
11. {textura.ReadPixels(new Rect(0, 0, rendtex.width,
rendtex.height), 0, 0);
12. textura.Apply ();
13. byte[] rawImage =textura.EncodeToJPG();
14. File.WriteAllBytes(Application.dataPath+"/Resources/img_orig.jp
g",rawImage); }}

5.2.ANEXA 2 CLASA DETECTOR

15. public class Detector : MonoBehaviour {

16. public void SalveazaImagine(Image<Bgr,Byte> img,string
nume) { try { img.Save (Application.dataPath + nume);}
17. catch(Exception Ex) {
18. Debug.Log (Ex.ToString ());} }
19.
20. public Image<Bgr,Byte> IncarcaImagine(String imageName){
21. try { Image<Bgr, Byte> img = new Image<Bgr, Byte>
(Application.dataPath+imageName);
22. return img;}
23. catch(Exception Ex) { Debug.Log (Ex.ToString ());
24. return null;}}
25.
26. public virtual Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte> img)
27. {return null;}
28.
29. public UMat aplicaCanny(Image<Bgr,Byte> img,double
Canny_thresh,double Canny_threshL)
30. { UMat contururi = new UMat ();
31. UMat image = aplicaGrayscale (img);
32. CvInvoke.Canny (image, contururi,
Canny_thresh,Canny_threshL);
33. return contururi; }
34.
35. public UMat aplicaGrayscale(Image<Bgr,Byte> img)
36. { UMat gray = new UMat ();

49
 37. CvInvoke.CvtColor (img, gray,
ColorConversion.Bgr2Gray);
38. return gray; } }
39.
40. public UMat aplicaGaussianBlur(UMat img,int kernel_gauss)
41. { UMat blur = new UMat ();
42. CvInvoke.GaussianBlur (img, blur, new Size
(kernel_gauss, kernel_gauss), 0, 0);
43. return blur; }
44.
45. public Image<Bgr,Byte> aplicaThreshhold(Image<Bgr,Byte>
img,double limita,double limita_max)
46. { UMat thres_img = new UMat ();
47. UMat gray = aplicaGrayscale (img);
48. CvInvoke.Threshold (gray, thres_img, limita,
limita_max, ThresholdType.Binary);
49. return thres_img.ToImage<Bgr,Byte> (); }}

5.3.ANEXA 3 CLASA MASINA

50. public class Masina : MonoBehaviour {

51. private Transform myTransform;
52. public bool ruleaza=false;
53. public float viteza =0.5f;
54. public string direcţie="faţa";
55. public bool manual=false;
56. public float limita=2000;
57. void Start () {
58. myTransform = this.transform;
59. ruleaza = false;}
60.
61. void Update () {
62. if (Input.GetKeyUp ("w")) {
63. ruleaza = !ruleaza;
64. direcţie = "faţa"; }
65. if (Input.GetKeyUp ("s")) {
66. ruleaza = !ruleaza;
67. direcţie = "Spate"; }
68. if (Input.GetKeyUp ("m")) {
69. viteza = 0.5f;
70. manual = !manual;}
71. if (ruleaza == true) {
72. mişcare (direcţie, viteza); }
Debug.Log ("Vit " + viteza); }
73.
74. public void mişcare(string direction,float speed)
75. { switch(direction){
76. case "Fata":
77. myTransform.position += Vector3.forward*speed;
78. break;

50
 79. case "Spate":
80. myTransform.position-=Vector3.forward*speed;
81. break;} }
82.
83. public void setViteza(float arie)
84. { if (manual != true) {
85. if (arie > limita) { viteza = 0.0f;}}
86. }

5.4.ANEXA 4 CLASA DETECTIE PIETONI

87. public class DetectiePietoni : Detector {

88. private Image<Bgr,Byte> imagine;
89. double arieMax = 0;
90. double arieReg=0;
91. public maşină maşină;
92. public double scor = 1.1;
93.
94. void Update(){
95. imagine = IncarcaImagine("/Resources/img_orig.jpg");
96. imagine = Proceseaza (imagine);
97. SalveazaImagine (imagine,"/Resources/pieton.jpg");}
98.
99. public override Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte> img)
100. { MCvObjectDetection[] regiuni;
101. using (HOGDescriptor DescriptorHOG = new HOGDescriptor (){
102. DescriptorHOG.SetSVMDetector
(HOGDescriptor.GetDefaultPeopleDetector ());
103. regiuni = DescriptorHOG.DetectMultiScale
(img,0,default(Size),default(Size),1.05,2,false);}
104. foreach (MCvObjectDetection regiune în regiuni) {
105. Debug.Log ("Score " + regiune.Score);
106. if (regiune.Score > scor) {
107. arieReg = regiune.Rect.Height *
regiune.Rect.Width;
108. if (arieReg > arieMax) {
109. arieMax = arieReg; }
110. img.Draw (regiune.Rect, new Bgr
(System.Drawing.Color.Red), 1);}}
111. Debug.Log ("Arie " + arieMax);
112. maşină.setViteza ((float)arieMax);
113. return img;}}

5.5.ANEXA 5 CLASA DETECTIE BENZI

114. public class DetectieBenzi : Detector {

115. public double rho=1;
116. public double theta=Math.PI/180.0 ;

51
 117. public int limita =50;
118. public double minLungimeLinie=50;
119. public double minDistanta=10;
120. public double Canny_thresh=100;
121. public double Canny_threshL=50;
122. private Image<Bgr,Byte> imagine;
123. private LineSegment2D vertline=new LineSegment2D (new
Point (0, 0), new Point (0, 50));
124. void Update()
125. { imagine = IncarcaImagine
("/Resources/img_orig.jpg");
126. imagine = Proceseaza (imagine);
127. SalveazaImagine (imagine,"/Resources/drum.jpg");
128. }
129. public override Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte>
img) { img.ROI = new Rectangle
(0,img.Height/2,img.Width,img.Height);
130. UMat Contururi = aplicaCanny
(img,Canny_thresh,Canny_threshL);
131. SalveazaImagine(Contururi.ToImage<Bgr,Byte>(),"/Resources/drum_
Canny.jpg");
132. LineSegment2D[] linii = CvInvoke.HoughLinesP (
133. Contururi,
134. rho,
135. theta,
136. limita,
137. minLungimeLinie,
138. minDistanta );
139.
140. foreach (LineSegment2D linie în linii) {
141. double angle = linie.GetExteriorAngleDegree (vertline);
142. Debug.Log ("Angle " + angle);
143. if (angle < 80.0 || angle>90.0 ) {
144. if(linie.Length>100){
145. Point p1 = linie.P1;
146. Point p2 = linie.P2;
147. bool dr = CvInvoke.ClipLine (new
Rectangle (img.Width / 2, 0, img.Width / 2, img.Height), ref p1, ref
p2); if (dr == true) {
148. img.Draw (linie, new Bgr
(System.Drawing.Color.Green), 3);} else {
img.Draw (linie, new Bgr (System.Drawing.Color.Red), 3);}}}}
149. return img;}}

5.6.ANEXA 6 CLASA DETECTIE SEMN STOP

150. public class DetectieSemnSTOP : Detector

151. { public int limita_joasa = 20;
152. public int limita_inalta = 160;
153. public int Canny_thresh = 100;

52
 154. public int Canny_threshL = 50;
155. public double arie = 0.1;
156. public maşină maşină;
157. public bool closed = true;
158. double arieMax = 0;
159. private Image<Bgr,Byte> imagine;
160. void Update ()
161. { imagine = IncarcaImagine
("/Resources/img_orig.jpg");
162. imagine = Proceseaza (imagine);
163. SalveazaImagine (imagine,
"/Resources/semn_stop.jpg");
164. }
165.
166. public override Image<Bgr,Byte> Proceseaza
(Image<Bgr,Byte> img)
167. { img.ROI = new Rectangle (img.Width / 2, 0, img.Width
/ 2, img.Height);
168. UMat Canny = new UMat ();
169. Mat channel1 = new Mat ();
170. Mat channel2 = new Mat ();
171. Mat hsv = new Mat ();
172. CvInvoke.CvtColor (img, hsv,
ColorConversion.Bgr2Hsv);
173. CvInvoke.ExtractChannel (hsv, channel1, 0);
174. CvInvoke.ExtractChannel (hsv, channel2, 1);
175. ScalarArray lower = new ScalarArray (limita_joasa);
176. ScalarArray upper = new ScalarArray (limita_inalta);
177. CvInvoke.InRange (channel1, lower, upper, channel1);
178. CvInvoke.BitwiseNot (channel1, channel1);
179. CvInvoke.Threshold (channel2, channel2, 10, 255,
ThresholdType.Binary);
180. CvInvoke.BitwiseAnd (channel1, channel2, channel1,
null);
181. CvInvoke.GaussianBlur (channel1, channel1, new Size
(5, 5), 2, 0, (BorderType)4);
182. Canny = aplicaCanny (channel1.ToImage<Bgr,Byte> (),
Canny_thresh, Canny_threshL);
183. SalveazaImagine (eroded,
"/Resources/stop_erode.jpg");
184. SalveazaImagine (channel1.ToImage<Bgr,Byte> (),
"/Resources/stop_thresh.jpg");
185. SalveazaImagine (Canny.ToImage<Bgr,Byte> (),
"/Resources/stop_Canny.jpg");
186. List<CircleF> listaCercuri = new List<CircleF> ();
187. VectorOfVectorOfPoint contururi = new
VectorOfVectorOfPoint ();
188. CvInvoke.FindContours (Canny,
189. contururi, null,
190. RetrType.List,
191. ChainApproxMethod.ChainApproxSimple,

53
 192. default(Point));
193. int nrContururi = contururi.Size;
194. for (int i = 0; i < nrContururi; i++) {
195. VectorOfPoint contur = contururi [i];
196. VectorOfPoint conturAproximat = new
VectorOfPoint ();
197. CvInvoke.ApproxPolyDP (
198. contur,
199. conturAproximat,
200. 5,
201. closed
202. );
203. if (CvInvoke.ContourArea (conturAproximat,
false) > arie) { listaCercuri.Add
(CvInvoke.MinEnclosingCircle (conturAproximat));
204. } }
205.
206. foreach (CircleF cerc în listaCercuri) {
207. if (cerc.Area > arieMax) {
208. arieMax = cerc.Area;}
209. img.Draw (cerc, new Bgr
(System.Drawing.Color.Green), 2);}
210. maşină.setViteza ((float)arieMax);
211. return img; }}

5.7.ANEXA 7 CLASA DETECTIE SEMAFOR

212. public class DetectieSemafor : Detector {

213. public int limita_joasa=30;
214. public int limita_inalta=170;
215. public int Canny_thresh=100;
216. public int Canny_threshL=50;
217. public double arie = 0.1;
218. public maşină maşină;
219. double arieMax = 0;
220. private Image<Bgr,Byte> imagine;
221. void Update()
222. { imagine = IncarcaImagine
("/Resources/img_orig.jpg");
223. imagine = Proceseaza (imagine);
224. SalveazaImagine (imagine,"/Resources/semafor.jpg");}
225.
226. public override Image<Bgr,Byte> Proceseaza(Image<Bgr,Byte>
img)
227. { img.ROI = new Rectangle
(img.Width/2,0,img.Width/2,img.Height);
228. UMat Canny=new UMat();
229. Mat channel1 = new Mat();
230. Mat channel2 = new Mat();
231. Mat hsv=new Mat();

54
 232. CvInvoke.CvtColor(img, hsv,
ColorConversion.Bgr2Hsv);
233. CvInvoke.ExtractChannel(hsv, channel1, 0);
234. CvInvoke.ExtractChannel(hsv, channel2, 1);
235. ScalarArray lower = new
ScalarArray(limita_joasa) ;
236. ScalarArray upper = new
ScalarArray(limita_inalta) ;
237. CvInvoke.InRange(channel1, lower, upper,
channel1);
238. CvInvoke.BitwiseNot(channel1,channel1);
239. CvInvoke.Threshold(channel2,channel2, 10, 255,
ThresholdType.Binary);
240. CvInvoke.BitwiseAnd(channel1, channel2,
channel1, null);
241. CvInvoke.GaussianBlur (channel1, channel1,new
Size(5,5), 2,0,(BorderType)4);
242. Canny = aplicaCanny
(channel1.ToImage<Bgr,Byte> (), Canny_thresh, Canny_threshL);
243.
244. SalveazaImagine (channel1.ToImage<Bgr,Byte>
(), "/Resources/semafor_thresh.jpg");
245. SalveazaImagine (channel1.ToImage<Bgr,Byte>
(), "/Resources/semafor_Canny.jpg");
246. List<CircleF> listaCercuri = new List<CircleF>
();
247. VectorOfVectorOfPoint contururi = new
VectorOfVectorOfPoint ();
248. CvInvoke.FindContours (Canny,
249. contururi,null,
250. RetrType.List,
251. ChainApproxMethod.ChainApproxSimple,
252. default(Point));
253. int nrContururi = contururi.Size;
254. for (int i = 0; i < nrContururi; i++) {
255. VectorOfPoint contur = contururi [i];
256. VectorOfPoint conturAproximat = new
VectorOfPoint ();
257. CvInvoke.ApproxPolyDP (
258. contur,
259. conturAproximat,
260. 5,
261. true );
262. if (CvInvoke.ContourArea (conturAproximat,
false) > arie) { listaCercuri.Add (CvInvoke.MinEnclosingCircle
(conturAproximat));}}
263.
264. foreach (CircleF cerc în listaCercuri) {
265. if (cerc.Area > arieMax) {
266. arieMax = cerc.Area;}
267. img.Draw (cerc, new Bgr

55
 (System.Drawing.Color.Green), 2);}
268. maşină.setViteza ((float)arieMax);
269. return img; }

5.8.ANEXA 8 CLASA DETECTIE MASINI

270. public class DetectieMasini : Detector

271. {
272. public double tresh = 125;
273. public double treshMax = 255;
274. public double Canny_thresh = 100;
275. public double Canny_threshL = 50;
276. public int[] limite;
277. public int limita_inalta = 100;
278. public double arie = 100;
279. public int j = 3;
280. private Image<Bgr,Byte> imagine;
281. void Start()
282. {limite = new int[3];}
283.
284. void Update ()
285. { imagine = IncarcaImagine
("/Resources/img_orig.jpg");
286. imagine = Proceseaza (imagine);
287. SalveazaImagine (imagine, "/Resources/maşini.jpg");}
288.
289. public override Image<Bgr,Byte> Proceseaza
(Image<Bgr,Byte> img)
290. { img.ROI = new Rectangle (0, img.Height / 2,
img.Width, img.Height);
291. UMat Canny = new UMat ();
292. Mat channel1 = new Mat ();
293. Mat channel2 = new Mat ();
294. Mat hsv = new Mat ();
295. limite [0] = 20;
296. limite [1] = 240;
297. limite [2] = 215;
298. CvInvoke.CvtColor (img, hsv,
ColorConversion.Bgr2Hsv);
299. CvInvoke.ExtractChannel (hsv, channel1, 0);
300. CvInvoke.ExtractChannel (hsv, channel2, 1);
301. SalveazaImagine (channel2.ToImage<Bgr,Byte> (),
"/Resources/maşini_hue.jpg");
302. List<RotatedRect> listaDreptunghi = new
List<RotatedRect> ();
303. for (j =0 ;j< 3;j++) {
304. ScalarArray lower = new ScalarArray (limite
[j]);
305. ScalarArray upper = new ScalarArray
(limita_inalta);

56
 306. CvInvoke.InRange (channel2, lower, upper,
channel2);
307. CvInvoke.BitwiseNot (channel2, channel2);
308.
309. CvInvoke.GaussianBlur (channel2, channel2, new
Size (5, 5), 2, 0, (BorderType)4);
310.
311. SalveazaImagine (channel2.ToImage<Bgr,Byte>
(), "/Resources/maşini_thresh.jpg");
312. Canny = aplicaCanny
(channel2.ToImage<Bgr,Byte> (), Canny_thresh, Canny_threshL);
313. SalveazaImagine (Canny.ToImage<Bgr,byte> (),
"/Resources/maşini_Canny.jpg");
314. Debug.Log ("j " + j);
315. VectorOfVectorOfPoint contururi = new
VectorOfVectorOfPoint ();
316.
317. CvInvoke.FindContours (Canny,
318. contururi, null,
319. RetrType.List,
320. ChainApproxMethod.ChainApproxSimple,
321. default(Point));
322. int nrContururi = contururi.Size;
323. for (int i = 0; i < nrContururi; i++) {
324. VectorOfPoint contur = contururi [i];
325. VectorOfPoint conturAproximat = new
VectorOfPoint ();
326. CvInvoke.ApproxPolyDP (
327. contur,
328. conturAproximat,
329. 5,
330. true
331. );
332. if (CvInvoke.ContourArea
(conturAproximat, false) > arie) {
333. listaDreptunghi.Add (CvInvoke.MinAreaRect
(conturAproximat)); }}}
334. foreach (RotatedRect dreptunghi în listaDreptunghi)
{img.Draw (dreptunghi, new Bgr (System.Drawing.Color.Green), 2); }
335. return img; }}

57
6.BIBLIOGRAFIE

1. J. R. Parker , Algorithms for Image Processing and Computer Vision (2nd

ed.) , Wiley (2011)
2. Gloria Bueno Garcia ,Ismael Serrano Garcia , Learning Image Processing With
OpenCV , Packt (2015)
3. Joseph Howse , OpenCV Computer Vision with Python , Packt (2011) [pag.35-
170]
4. Jan Eric Solem , Programming Computer Vision , O'Reilly (2009)[pag.50-178]
5. www.OpenCV.com
6. D.Forsyth, J.Ponce ,Computer Vision - A Modern Approach,Pearson [pag.10-
235] (2012)
7. http://www.edwardrosten.com/work/fast.html
8. http://robotics.eecs.berkeley.edu/~sastry/ee20/cacode.html
9. http://www.library.cornell.edu/preservation/tutorial/
10.http://unity3d.com/
11.http://asirt.org/initiatives/informing-road-users/road-safety-facts/road-crash-
statistics
12 .http://www.statisticbrain.com/car-crash-fatality-statistics-2/
13. http://www.emgu.com/wiki/index.php/Main_Page
14. Robert Laganiere , OpenCV 3 Computer Vision Application Programming
Cookbook - Third Edition , Packt (2015) [pag.7-50]
15.Gary Bradski ,Adrian Kaehler ,Computer Vision with the OpenCV Library ,
O'Reilly (2014) [pag.20-86]
16.Richard Szeliski ,Computer Vision: Algorithms and Applications ,Springer
(2014) [pag.56-275]
17. http://www.nvidia.com/object/drive-px.html
18. http://spectrum.ieee.org/automaton/robotics
19. http://www.mobileye.com/products/
20. http://itseez.com/products/
21. http://www.luxoft.com/automotive/adas-computer-vision/
22. www.hktdc.com/manufacturers-suppliers/PLK-Technologies-Co-Ltd/
23. http://www.merl.com/research/computer-vision

58