Messa a fuoco - Telecamere lineari - Analisi e tuning del sistema di elaborazione di una macchi

3.2 Telecamere lineari

3.2.2 Messa a fuoco

La scarsa illuminazione ha come ulteriore effetto quello di peggiorare la messa a fuoco. Un altro fattore che può causare la sfocatura dell’immagine è l’errata sincronizzazione tra la movimentazione del tubo e l’acquisizione dell’immagine. Con le telecamere lineari l’immagine acquisita non è mai verificabile in tempo reale, ma solamente al termine della scansione (nel caso in questione ogni 1000 linee), le operazioni di messa a fuoco e di regolazione del diafram- ma risultano perciò poco immediate. Per questi motivi le immagini acquisite dalle telecamere lineari possono essere migliorate operando sulla messa a fuoco dei dispositivi ottici, sulla sincronizzazione della velocità di scorrimento con la velocità di acquisizione dei sensori ottici o manipolando le immagini con algoritmi numerici opportuni, ovvero tramite filtri digitali di sharpening.

3.2.3 Sensori difettosi

Come abbiamo già detto, una telecamera lineare è formata da un array di sensori ottici posti uno di fianco all’altro. Se uno di questi sensori è difettoso o addirittura non funzionante, questo genera sul frame come una linea molto più chiara o molto più scura (in base al guadagno del pixel difettoso) che si protrae lungo tutta l’immagine, sulla linea acquisita da quel sensore. Analizzando per esempio le immagini precedenti (figure 3.3 e3.4) si possono notare delle righe verticali più marcate rispetto alle altre. Tali colonne, ana-

logamente al caso precedente, potrebbero disturbare il riconoscimento delle anomalie di interesse per l’applicazione.

3.3 Polvere

La polvere costituisce un problema non eliminabile dato l’ambiente indu- striale in cui il sistema opera. La polvere diviene insidiosa quando si de- posita sull’obbiettivo della telecamera e ivi permane. In tale situazione, si ha che la colonna1 _{in concomitanza del granello di polvere appare come una}

striscia molto più scura rispetto a tutto il resto dell’immagine. In tal senso, costituisce un problema, proprio perché, tale zona più scura potrebbe essere riconosciuta erroneamente dal sistema come un’anomalia (ad esempio una lunga riga d’aria) che porterebbe all’eliminazione del segmento di tubo, o di tutti i segmenti di tubo fintanto che il granello di polvere permane sull’obbiettivo. Si riporta nell’immagine3.4l’effetto della polvere sopra all’obiettivo della telecamera: tale anomalia si può vedere nella parte più a sinistra del- l’immagine e si presenta come una linea verticale più marcata lungo tutta l’immagine. Estraendo l’informazione, tramite un’operazione di soglia (mo- strando solo i livelli di grigio compresi tra 175 e 230) si evidenzia il fatto che l’informazione contenuta nell’immagine per quanto riguarda la riga d’aria e l’effetto del granello di polvere è compresa all’interno degli stessi livelli di grigio che vanno, appunto da 175 a 230. La polvere è dannosa anche per la produzione stessa. Infatti può depositarsi sopra al tubo di vetro ancora caldo, e rimanerci, rendendo il tubo, e i prodotti da esso ricavati, inutilizzabili.

Figura 3.4: Effetto della polvere sull’obbiettivo della telecamera

3.4 Temperatura

Poiché i sensori CCD su cui è basato il funzionamento delle telecamere in- stallate sul sistema sono molto sensibili alle variazioni di temperatura, queste vengono equipaggiate con un sistema di raffreddamento e con un sensore di temperatura. Il sistema di raffreddamento ha il compito di ridurre il più possibile il disturbo, ovvero il rumore di tipo gaussiano, dovuto alla temperatura. Tale rumore andrebbe infatti a mescolarsi col segnale, generando una cattiva qualità delle immagini finali. Il sistema di raffreddamento è general- mente di tipo termoelettrico. È costituito da una piccola pompa di calore ad effetto Peltier, una cella che sfrutta la corrente elettrica per produrre un abbassamento della temperatura. Questo abbassamento in condizioni di temperatura ambiente di 25◦_{C funziona molto bene e riesce a stabilizzare la}

temperatura sui sensori in modo da eliminare il rumore. In condizioni estre- me per´o, come nel caso del sistema in questione, dove il vetro fuso arriva a temperature sui 540 ◦_{C, le telecamere vengono inevitabilmente surriscal-}

date. Se la temperatura sul sensore supera i 90 ◦_{C i dispositivi vengono}

irrimediabilmente danneggiati. L’incremento della temperatura con valori anche entro la soglia massima comporta comunque un deterioramento delle prestazioni del dispositivo in termini di qualit`a dell’immagine. Il costruttore nel manuale delle telecamere utilizzate, le Basler L101k, consiglia l’utilizzo delle stesse in un ambiente con temperatura non superiore ai 50 ◦_{C. Per tale}

motivo la temperatura andr`a monitorata continuamente tramite il sensore di cui `e equipaggiata.

3.5 Tempo di elaborazione

L’ultimo elemento critico sul quale vogliamo attirare l’attenzione del lettore è il tempo. Tutti gli aspetti critici esposti in precedenza verranno tratta- ti in modo digitale, utilizzando quindi algoritmi numerici e filtri digitali ad hoc. Il Tempo a disposizione dipende dalla velocità di trasporto del tubo: da quando viene catturato un frame il tempo per compiere tutte le elaborazioni e decidere se va scartato o tenuto scade non appena quel tubo arriva alla macchina tagliatrice e potrà essere fisicamente scartato. Solitamente si prende come tempo utile per elaborare l’immagine in tutti i passaggi visti nella figura 2.1, il tempo di campionamento delle telecamere: 125 ms. Quindi una volta catturato un frame, si ha tempo solamente fino alla cattura del frame successivo per effettuare la pre-elaborazione, applicare il fitro Canny e poi riconoscere eventuali difetti presenti e catalogarli.

Un altro livello di deadline riguarda l’intero tubo di 1.57 m, ovvero scade ogni 500 ms. Ogni 500 ms si devono esaminare tutti i difetti presenti nel tubo, e stabilire se sono tali da causare l’eliminazione del tubo stesso.

Algoritmi proposti

In riferimento ai problemi visti nel capitolo 3 a pagina 42 si riporta la lista dei fattori critici per il sistema di visione:

1. Movimento del tubo

Movimento ondulatorio del tubo Curvatura del tubo

2. Telecamere Lineari

Illuminazione non uniforme Messa a fuoco

Sensori difettosi 3. Polvere

4. Temperatura

5. Tempo di elaborazione

Si riporteranno di seguito le soluzioni che sono state implementate per alcuni di essi. Prima di procedere all’analisi delle soluzioni, si proceder`a per`o

a mostrare il punto del sistema gi`a presente al momento di inizio di questo lavoro di tesi in cui si intende inserire le modifiche.

4.1 La funzione IndividuaROIImmagine()

Figura 4.1: Assi di riferimento

Nell’applicazione esistente prima dell’inizio di questa tesi, la funzione IndividuaROIImmagine() svolge le operazioni di pre-elaborazione. Es- sa è preposta, come di può intuire dal nome, a individuare le coordina- te, espresse come un numero intero che indica l’indice della riga e della colonna, dei bordi del tubo all’interno dell’immagine, cos`ı da poter individuare un dentro e un fuori. Per convenzione si pone lo zero degli assi di riferimento cartesiani per gli indici di riga e colonna nelle immagini digitali centrato sullo spigolo in alto a sinistra dell’immagine stessa, come mostrato in figura 4.1. I suoi risultati vengono poi utilizzati dalla fase di elaborazione: una volta trovati i bordi del tubo si applicherà alla parte interna al tubo, che nel nostro caso rappresenta la regione di interesse (ROI), il filtro Canny per trovare i difetti presenti. Infatti per minimizzare i tempi di esecuzione dell’algoritmo di Canny, che risultano non trascurabili, si applica lo stesso solamente a una porzione ridotta dell’immagine, la ROI, appunto.

Abbiamo eletto la funzione IndividuaROIImmagine() come la pi`u indicata a contenere il codice degli algoritmi di smoothing e di analisi dell’immagine. Abbiamo poi introdotto anche un altro metodo per rintracciare i bordi del

tubo integrandolo con le operazioni di filtraggio e integrando il tutto nella nuova funzione IndividuaROIImmagineFiltraggio() nella quale abbiamo lasciato inalterato il prototipo della funzione IndividuaROIImmagine(), in modo tale da poterla sostituire nell’applicazione senza apportare nessun’al- tra modifica all’infuori del nome stesso della funzione, lasciando la possibilit`a di continuare a utilizzare anche la vecchia versione gi`a testata e collaudata.

1 void I n d i v i d u a R O I I m m a g i n e F i l t r a g g i o ( I p l I m a g e ∗img , I p l I m a g e ∗mask ,i n t ∗ bordoSX , i n t ∗ bordoDX , b o o l ∗ t u t t o N e r o )

Argomento Significato

IplImage *img immagine da modificare

IplImage *mask immagine usata per visualizzare i risultati int *bordoSX Indice del bordo sinistro interno

int *bordoDX Indice del bordo destro interno

bool *tuttoNero Attualmente non utilizzato `e sempre false

La funzione IndividuaROIImmagine(), riportata integralmente in appendice A, contiene un algoritmo funzionante per il reperimento di bordi del tubo. Se ne analizza di seguito il funzionamento per capirne i limiti e i punti di forza, e decidere se mantenerlo inalterato, oppure modificarlo in funzione delle nuove esigenze di robustezza richieste.

4.1.1 Algoritmo 1

La funzione inizia con la dichiarazione delle variabili che verranno utilizzate nel suo corpo. Ne riportiamo di seguito la lista al fine di mettere il lettore in grado di leggere l’algoritmo che seguir`a, avendo chiaro il tipo di ogni vatiabile e la sua descrizione breve. La funzione, come del resto tutto l’intero sistema, utilizza le librerie OpenCV, e quindi i metodi di apertura, salvataggio,

scorrimento ed elaborazione dei pixel delle immagini utilizzano i metodi e le interfacce proprie di tali librerie, che abbiamo gi`a avuto modo di descrivere in precedenza.

1 void I n d i v i d u a R O I I m m a g i n e F i l t r a g g i o ( I p l I m a g e ∗img , I p l I m a g e ∗mask , i n t∗ bordoSX , i n t∗ bordoDX , b o o l ∗ t u t t o N e r o ) { 2 3 i n t h e i g h t , width , s t e p ; // i n d i c i p e r s c o r r e r e i p i x e l d e l l ’ immagine 4 // r i s p e t t i v a m e n t e l a r g h e z z a e l u n g h e z z a 5 u c h a r ∗ d a t a ; // p u n t a t o r e a l l ’ immagine da e l a b o r a r e 6 i n t ∗ a v g B u f f e r ; // v e t t o r e con l e somme p e r c o l o n n e 7

8 // v e t t o r e con l e d i f f e r e n z e t r a un i n t e r v a l l o prima e dopo i l punto

9 s t a t i c i n t ∗ d i f f B u f f e r = NULL ; 10 // D i m e n s i o n e d e l l a f i n e s t r a p e r l a media s u l l e r i g h e 11 const i n t FINESTRA = 3 0 ; 12 // O f f s e t t r a i l b o r d o e i l punto i n c u i v i e n e a p p l i c a t a l a m a s c h e r a 13 const i n t OFFSET = 4 0 ; 14 15 // S o g l i a massima e minima d i g r i g i o d e l r a n g e d i t o n a l i t `a c o n t e n e n t i i l b o r d o 16 const i n t VALOREDISCURO = 3 0 ; 17 const i n t VALOREDICHIARO = 1 0 0 ; 18 19 // I n i z i a l i z z a z i o n e d e l l ’ immagine 20 h e i g h t = img−>h e i g h t ; // 1000 21 w i d t h = img−>w i d t h ; // 2048 22 s t e p = img−>w i d t h S t e p ; // 2048 23 d a t a = ( u c h a r ∗ ) img−>imageData ; 24 25 // c r e o un v e t t o r e p e r ognuna d e l l e 2048 c o l o n n e 26 // i n c u i i n s e r i r e l e somme c u m u l a t i v e ad o g n i p a s s o 27 a v g B u f f e r = new i n t[ w i d t h ] ; 28 // s e `e i l primo p a s s o c r e o i l v e t t o r e p e r l e d i f f e r e n z e 29 // p e r ognuna d e l l e 2048 c o l o n n e e l o i n i z i a l i z z o a 0 30 i f( d i f f B u f f e r == NULL) { 31 d i f f B u f f e r = new i n t[ w i d t h ] ;

32 f o r(i n t kappa = 0 ; kappa < w i d t h ; kappa++){ 33 d i f f B u f f e r [ kappa ] = 0 ; 34 } 35 } 36 37 // v a r i a b i l i p e r i b o r d i 38 i n t b o r d o S X I n t e r n o L o c a l = 0 , maxSXInterno = 0 ; 39 i n t b o r d o D X I n t e r n o L o c a l = 0 , minDXInterno = 0 ; 40 i n t b o r d o S X E s t e r n o L o c a l = 0 , minSXEsterno = 0 ; 41 i n t b o r d o D X E s t e r n o L o c a l = 0 , maxDXEsterno = 0 ; 42 43 i n t numLine = 0 ; 44 45 i f( t u t t o N e r o != NULL) 46 ∗ t u t t o N e r o = t r u e ; 47 48 i f( c e n t r o T u b o == NULL)

c e n t r o d e l tubo 50 e l s e{ 51 d e l e t e ( c e n t r o T u b o ) ; 52 c e n t r o T u b o = new i n t[ ( h e i g h t /PASSO + 1 ) ∗ 2 ] ; 53 } 54 55 i n t numeroPassoCentroTubo = 0 ; 56 57 <... >

A questo punto possiamo dunque descrivere a parole come opera l’algoritmo, per poi riportarne il codice. L’algoritmo, calcola una serie di medie pesate e differenze, e le confronta con alcune soglie, entro le quali si sup- pongono essere le intensità dei bordi. Analizzando più in dettaglio possiamo affermare che l’algoritmo è contenuto dentro a un ciclo for e viene eseguito su un numero di righe costante e variabile in base al tipo di produzione in corso. Tale numero prende il nome di PASSO ed è stato definito pari a 10 in fase di testing e di sviluppo del sistema. Questo significa che l’immagine di 2048x1000 pixel viene scomposta in 1000/PASSO sotto-immagini e l’algoritmo viene applicato sistematicamente ad ognuna di esse. In fase di sviluppo, l’algoritmo viene applicato 1000/10 = 100 volte per ogni immagine. I motivi di questo modus operandi sono legati al movimento oscillatorio del tubo, e verranno analizzati di seguito, nel paragrafo4.2. Supponiamo che l’algoritmo sia già a regime, e quindi di non essere alla prima sotto-immagine, supponiamo di essere giunti ad analizzare l’n-esima. Per tutte le 2048 colonne, inserisco in avgBuffer[i] la somma dei valori dei PASSO pixel della i-esima colonna. 56 <... > 57 58 f o r(i n t i n d e x L i n e = 0 ; i n d e x L i n e < h e i g h t ; i n d e x L i n e+=numLine , numeroPassoCentroTubo++) 59 { 60 <... > 61 62 // Fa l a somma s u PASSO c o l o n n e 63 f o r(i n t i = 0 ; i < numLine ; i ++){ 64 f o r (i n t j = 0 ; j < w i d t h ; j ++){

65 a v g B u f f e r [ j ] += d a t a [ ( i n d e x L i n e + i ) ∗ s t e p + j ] ; 66 } 67 } 68 69 f o r(i n t g i e i = FINESTRA ; g i e i < w i d t h − FINESTRA ; g i e i ++){ 70 d i f f B u f f e r [ g i e i ] = 0 . 8 ∗ d i f f B u f f e r [ g i e i ] + 0 . 2 ∗ C a l c o l a D i f f ( a v g B u f f e r , g i e i , FINESTRA) ; 71 } 72 73 <... >

Figura 4.2: Operazioni di Soglia

L’algoritmo procede calcolando i valori delle differenze diffBuffer[i]. Tali differenze non sono calcolate su tutta l’immagine, ma si lascia un margine di sicurezza pari a una FI- NESTRA a sinistra e una FINE- STRA a destra ovvero di analizza- no solo le colonne contenute nel se- guente insieme [30,2018]. La funzione int CalcolaDiff(int* buffer, int index, int finestra) è una piccola rou- tine di utilità che ritorna la differenza buffer[index+1] - buffer[index-1] In diffBuffer si inseriscono quindi le differenze tra le somme della colonna successiva e quelle della colonna precedente rispetto a quella che stiamo analizzando, pesate però, su tutta la storia passata, ovvero le differenze calcolate per le sotto-immagini precedenti. Come si può notare dal codice, la storia passata viene fatta pesare l’80% rispetto al valore attuale. Questo serve a limitare il contributo di eventuali picchi di contrasto nell’immagine, dovuti a problemi di tipo tipo, che spazia- no dal rumore, alla polvere sull’obbiettivo delle telecamere. Nell’applicazione

preesistente per la web inspection in tempo reale del prodotto, la funzione IndividuaROIImmagine()Da un punto di vista informale, l’algoritmo scorre colonna per colonna cercando di accorgersi quando la differenza di colore tra la colonna analizzata e quelle che ha nel suo intorno più immediato, supera una certa soglia, ovvero quando si passa da una tonalità di chiaro, lo sfon- do, allo scuro, il bordo. Se questa condizione è verificata, allora l’algoritmo ipotizza che siamo in presenza dell’inizio del primo bordo e procede alla ricer- ca della sua fine, utilizzando a questo punto soglie diverse, perché vogliamo adesso trovare quando la variazione di colore è da scuro a chiaro. Il sistema di soglie utilizzato si serve dei due valori costanti VALOREDICHIARO e VALOREDISCURO reperiti in una fase iniziale di studio del problema. Per individuare quelle due soglie, che valgono rispettivamente, 100 e 30, si è proceduto con operazioni di soglia a due valori: tali operazioni, standard nell’elaborazione digitale di immagini e segnali, e fornite dalle librerie Open- Cv, possono essere paragonate a filtri passa-banda: mostrano sull’immagine solamente le tonalità comprese tra la soglia inferiore e quella superiore che vengono indicate. Ad esempio, applicando la soglia [30,100] all’immagine 4.2

(b) si ottiene il risultato mostrato nell’immagine 4.2 (a).

80 const i n t MAX INIZIALE = (VALOREDISCURO + 2 0 ) ∗ numLine ; 81

82 i n t t r o v a t o P r i m o = 0 , min1 = MAX INIZIALE ; 83 i n t t r o v a t o S e c o n d o = 0 , min2 = MAX INIZIALE ; 84 i n t indexMin1 = 0 , indexMin2 = 0 ; 85 i n t biancoSX = 0 ; 86 87 b o r d o S X I n t e r n o L o c a l = 0 , maxSXInterno = 0 ; 88 b o r d o D X I n t e r n o L o c a l = 0 , minDXInterno = 0 ; 89 b o r d o S X E s t e r n o L o c a l = 0 , minSXEsterno = 0 ; 90 b o r d o D X E s t e r n o L o c a l = 0 , maxDXEsterno = 0 ; 91 i n t i n d e x M i n 1 F i n e = 0 ; 92 93 f o r(i n t i = 0 ; i < w i d t h ; i ++){ 94 i f( t r o v a t o P r i m o == 0 ) { 95 i f( a v g B u f f e r [ i ] < VALOREDISCURO∗ numLine ) { 96 min1 = a v g B u f f e r [ i ] ; 97 indexMin1 = i ; 98 }e l s e{

99 i f( min1 > VALOREDISCURO∗ numLine && a v g B u f f e r [ i ] > VALOREDICHIARO ∗ numLine ) {

100 biancoSX = 1 ;

101 }

102 i f( min1 < VALOREDISCURO∗ numLine && a v g B u f f e r [ i ] > VALOREDICHIARO ∗ numLine ) { 103 t r o v a t o P r i m o = 1 ; 104 i n d e x M i n 1 F i n e = i ; 105 } 106 } 107 }e l s e{ 108 i f( a v g B u f f e r [ i ] < VALOREDISCURO∗ numLine ) { 109 min2 = a v g B u f f e r [ i ] ; 110 indexMin2 = i ; 111 } 112 e l s e{

113 i f( min2 < VALOREDISCURO∗ numLine && a v g B u f f e r [ i ] > VALOREDICHIARO ∗ numLine ) { 114 t r o v a t o S e c o n d o = 1 ; 115 } 116 } 117 } 118 }

Si procede quindi a trovare tutti i bordi, come si evince dal codice ri- portato sopra. Si scorrono nuovamente tutte e 2048 colonne, e per ogni i compresa tra 0 e 2048 si cerca il valore minimo di avgBuffer[i],ovvero il valore che rispetta la condizione avgBuffer[i] ¡ VALOREDISCURO*numLine. La moltiplicazione per numLine serve perchè avgBuffer contiene una somma cumulativa di valori e non il valore medio. Quindi per confrontarlo con VALORDISCURO, moltiplico questo per numLine (che è uguale a PASSO) e quindi la condizione finale risulta avgBuffer[i] ¡ 300. Analogamente si fa per il valore chiaro, nelle condizioni successive. A questo punto l’algoritmo stabilisce se nell’immagine ci sono entrambi i bordi, o se è presente un solo bordo. Nel caso in cui sia presente un solo bordo, allora si calcola se la ROI è la parte a destra, oppure quella a sinistra del bordo trovato. Se non è presente nemmeno un bordo, si considera la ROI estesa a tutta l’immagine. Non riportiamo il codice relativo a questi due casi, ma continuiamo l’analisi dell’algoritmo nel caso normale di due bordi presenti nell’immagine. Osser-

vando una qualunque immagine dei un tubo, si noterà però che i bordi non sono mai netti e definiti, per tale motivo gli indici indexMin1 e indexMin2 isolati dall’algoritmo, fino a questo punto, sono stati trovati lavorando sulle differenze locali tra la colonna attuale e quelle adiacenti. Per recuperare il bordo reale, supponiamo il primo da sinistra, si cerca il valore minimo presente in diffBuffer[i] con i appartenente a [FINESTRA,indexMin1]. La stessa cosa verrà ripetuta per la sua fine, e per il secondo bordo del tubo. Per calcolare i valori massimi e minimi si si usano le due funzioni di utilità void trovaMax(int data[], int indexStart, int indexEnd, int *max, int *index- Max) e void trovaMin(int data[], int indexStart, int indexEnd, int *min, int *indexMin) in cui i parametri max e min funzionano anche come valore di soglia: il minimo ad esempio, viene restituito solo nel caso in cui diffBuffer[i] sia minore di min. Analogamente per il valore massimo restituito.

120 // Primo m a r g i n e da s i n i s t r a

121 t r o v a M i n ( d i f f B u f f e r , FINESTRA , indexMin1 , &minSXEsterno , &b o r d o S X E s t e r n o L o c a l ) ; 122 // S econ d o m a r g i n e da s i n i s t r a

123 trovaMax ( d i f f B u f f e r , indexMin1 , i n d e x M i n 1 F i n e , &maxSXInterno , & b o r d o S X I n t e r n o L o c a l ) ;

124 // T e r z o m a r g i n e da s i n i s t r a

125 t r o v a M i n ( d i f f B u f f e r , i n d e x M i n 1 F i n e , indexMin2 , &minDXInterno , & b o r d o D X I n t e r n o L o c a l ) ;

126 // Quarto m a r g i n e da s i n i s t r a

127 i f( indexMin2 > w i d t h − 5 )

128 b o r d o D X E s t e r n o L o c a l = w i d t h ;

129 e l s e

130 trovaMax ( d i f f B u f f e r , indexMin2 , width , &maxDXEsterno , & b o r d o D X E s t e r n o L o c a l ) ; 131 132 133 i f( ∗ bordoSX < b o r d o S X I n t e r n o L o c a l ) 134 ∗ bordoSX = b o r d o S X I n t e r n o L o c a l ; 135 i f( ∗ bordoDX > b o r d o D X I n t e r n o L o c a l ) 136 ∗bordoDX = b o r d o D X I n t e r n o L o c a l ; 137 138 <... >

Il valore finale restituito dalla funzione `e il bordoSXInternoLocal mag- giore di tutti, rispetto a quelli trovati in ogni sotto-immagine, mentre per il bordoDXInternoLocal `e il bordo minore di tutti.

Quello che descritto in precedenza rappresenta, in realtà, una versione già modificata dell’algoritmo nell’ottica di renderlo più robusto. Le modifiche che abbiamo apportato rispetto a quello primitivo, consistono esclusivamen- te nell’applicazione dell’algoritmo ad ogni sotto-immagine, anziché a tutta l’immagine intera una volta per tutte. Questo consente, come spiegato nel prossimo paragrafo, di rendere il sistema insensibile alle oscillazioni del tubo. L’algoritmo presentato, tuttavia, risulta molto ridondante perché scorre più volte la sotto-immagine che deve analizzare. Inoltre, va a scorrere gli array avgBuffer e diffBuffer più e più volte per ciascuna sotto-immagine. Se tenia- mo conto del fatto che tali array sono di dimensioni non trascurabili, ognuno di essi contiene 2048 interi, risulta evidente che il procedimento adottato è molto pesante e incide negativamente sulle prestazioni del sistema. Si ricorda che tale procedimento viene applicato 100 volte per ogni singola immagine. Nell’ottica di razionalizzare e di ottimizzare la funzione IndividuaROIImma- gine() potenziandola con le funzionalità descritte nel seguito di questo capitolo, cercheremo di individuare un algoritmo più veloce e snello che si integri maggiormente con quanto dovrà essere realizzato in seguito. In appendice si riporta il codice completo della funzione IndividuaROIImmagine().

Si procede quindi, all’analisi dei fattori critici veri e propri, proponendo contestualmente la soluzione che si `e ritenuta essere la migliore e la sua implementazione.

4.2 Movimento ondulatorio del tubo

Problema A causa del Movimento ondulatorio del tubo nell’immagine i bordi della ROI non sono rettilinei ma oscillano creando anse anche molto profonde che creano una ROI di forma irregolare. Nella versione

iniziale del sistema, venivano trovati due soli indici di inizio e fine della ROI validi per tutta l’immagine. In tal modo, se l’oscillazione dei bordi era troppo elevata, si rischiava, a causa dell’approssimazione, di perdere aree della ROI contenenti difetti.

Soluzione Si affetta l’immagine in sotto-immagini di dimensioni 2048xPAS- SO pixel e si trovano i bordi del tubo in ognuna fetta, esattamen- te come era già stato fatto in precedenza. Il PASSO potrà essere scelto in base al tipo di tubo in questione e all’oscillazione presente. Per i nostri test abbiamo fissato il PASSO una tantum in modo statico. La scelta di un PASSO troppo basso comporta l’aumen- to dei tempi di esecuzione, mentre un PASSO troppo elevato ridu- ce la precisione dell’algoritmo e potrebbe rendere inutile la soluzione. In fase di test abbiamo utilizzato un PASSO pari a 10 pixel. Ogni immagine è stata cos`ı divisa in 100 sotto-immagini, ottenendo 100 coppie (bordoSXInternoLocal, bordoDXInternoLocal) e altre 100 del tipo (bordoSXEsternoLocal, bordoDXEsternoLocal). Le variabili bordoSx e bordoDX ritornate dalla funzione saranno scelte in modo da minimizzare l’errore di approssimazione. Si riporta di seguito il nuo- vo algoritmo proposto per rintracciare i bordi della ROI, e a seguito faremo un confronto con l’algoritmo esistente 4.1.1.

Nel documento Analisi e tuning del sistema di elaborazione di una macchina di ispezione per il controllo di qualità del tubo vetro (pagine 54-69)