PROF. DR. JACQUES FACON ESTUDO DA TÉCNICA DE LIMIARIZAÇÃO DE EIKVIL

Transcrição

1 PUCPR- PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ PPGIA- PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA APLICADA PROF. DR. JACQUES FACON ESTUDO DA TÉCNICA DE LIMIARIZAÇÃO DE EIKVIL Resumo: Este trabalho tem por objetivo descrever o método de limiarização de imagens de Eikvil. Este estudo teórico tem por objetivo descrever o funcionamento do algoritmo para implementação na plataforma Pdimagem, utilizando-se a linguagem de programação Visual C++. O método de Eikvil constitui-se de duas janelas flutuantes: uma maior, e uma menor que fica posicionada no centro da janela maior. As janelas são movidas em passos iguais ao tamanho da janela menor. Um agrupamento dos pixels na janela maior é feito segundo o método de Otsu de seleção de limiarização. Um teste é efetuado para saber se a região consiste de uma ou duas classes, e assim os pixels na janela menor são classificados. Movendo-se as janelas desta maneira e usando-se uma técnica de agrupamento de pixels como a de Otsu, pode-se reter o contraste local e obter-se uma boa limiarização de imagens. Em testes realizados em várias imagens, obteve-se bons resultados, apesar de o método ser computacionalmente lento, tornando-se vantajosa a sua utilização. Palavras chaves: Processamento de imagens, Binarização, Método de Otsu, Método de Eikvil. Introdução A segmentação de imagens de tons de cinza como, por exemplo, o método de binarização (limiarização), é uma importante ferramenta para processamento de imagens. Tal técnica se constitui em separar a imagem de tons de cinza em duas classes: o background e o foreground. Existem diversas técnicas bem conhecidas de limiarização, mas estas técnicas apresentam muitas limitações. Propõe-se, então, um novo método que proporcione uma mais confiável limiarização de imagens de tons de cinza, com variações possíveis de contraste, que não podiam ser anteriormente limiarizadas utilizando-se outras técnicas.. Descrição do método Visando manter o algoritmo de limiarização sensível a contrastes e ruídos em imagens, o método de Eikvil utiliza uma técnica específica de análise de sub-imagens. Um agrupamento (clustering) é efetuado localmente em cada região (sub-imagem), e um teste é então realizado para se saber se a região consiste de uma ou duas classes. Após esta classificação, as médias das classes background e foreground são atualizadas, antes de se passar para o próximo passo. Cada sub-imagem constitui-se de duas janelas flutuantes: uma maior, e uma menor que fica posicionada no centro da maior. As janelas são movidas em passos iguais ao tamanho da janela menor, sendo que a janela menor move-se dentro da janela maior, sempre se posicionando no centro de gravidade da mesma. A cada passo, um agrupamento (clustering) é efetuado nos pixels contidos na janela maior, mas somente os pixels contidos na janela menor são classificados. Deve-se ressaltar que a escolha do tamanho da janela maior é importante, pois a região deve conter um número suficiente de pixels para se estimar parâmetros específicos de classe, enquanto deve também ser mantida pequena suficiente para preservar detalhes. Assim, a regra de classificação é adaptada a cada janela menor, e deste modo o risco de se perder detalhes menores é reduzido. As médias das duas classes são atualizadas conforme a imagem é percorrida, e são adaptadas às variações de nível de cinza da imagem. Como não deve haver

2 nenhuma relação entre os níveis de cinza das bordas esquerda e direita da imagem, as janelas são movidas em zigzag da esquerda para a direita, e novamente da direita para a esquerda. Um agrupamento dos pixels na janela maior é feito segundo o método de Otsu de seleção de limiarização. O método de Otsu foi escolhido porque produz clusters de, aproximadamente, mesmo tamanho. Deste modo, o risco de classificação errônea de pixels é reduzido. Além disso, o método de Otsu tem a vantagem de ser computacionalmente rápido. O método de Otsu não possui contexto, e leva em conta somente o histograma de tons de cinza. Todas as possíveis divisões (limiares) do histograma são testadas, e um valor que expressa a variação entre dois clusters, σ, é computado. O valor de limiar, t 0,,...L, que maximiza esta variação é selecionado. onde: B A variação entre dois clusters é expressa como: t σ = ϖ B ϖ ( t) = p i, = t ϖ ( t) i p i ( t )( T ) + ( ϖ ( t))( T é a média da classe c, e c, tendo-se o número total de níveis de cinza, L, o número total de pixels, N, ) é a média da classe 55 = i. p i ϖ ( t) t+ L ni pi = e T = i. p i. N Para a implementação desta técnica na plataforma de programação Visual C++, utilizou-se uma fórmula estatística para o cálculo e : t 0 = t 0 55 t = 55 t i. h( i) h( i) i. h( i) h( i) onde t é o valor de limiar de Otsu (janela maior), h é o histograma no nível de cinza i, é a média da classe preto ( c ) e é a média da classe branco ( c ). O método de Otsu sempre irá produzir dois clusters, e em seguida um teste é efetuado para se saber se a região é constituída de uma ou duas classes. Este teste é efetuado calculando-se a diferença entre as médias dos dois clusters. Se o módulo desta diferença (distância) for superior ao valor θ, a região consiste de duas classes. Caso contrário, a região consiste de apenas uma classe. Para a implementação do algoritmo requer-se a definição de alguns parâmetros. A região R e os passos L definem o tamanho das duas janelas flutuantes. Um valor θ de limite da distância entre as médias dos clusters é também necessário, bem como uma medida que determina a rapidez ω de adaptação, dos valores das médias globais, às variações de níveis de cinza na imagem. Ë necessário também a inclusão de um valor mínimo global e um valor máximo global. Utilizando-se esses valores, pode-se pré-classificar alguns dos pixels, definindo-se quais valores devem ser considerados no processo de agrupamento (clustering). Este processo é somente utilizado em imagens complexas onde o background e o foreground consistem realmente em duas classes e onde essas classes aparecem juntas. Estes dois parâmetros podem ser estimados, por exemplo, agrupando-se todos os pixels em 5 clusters, e escolhendo-se o maior e menor valor das médias dos clusters, respectivamente como os valores globais máximo e mínimo.

3 3. Algoritmo Define-se uma região R, de tamanho nxn, e uma janela L, de tamanho mxm, sendo que m < n. Posiciona-se então a janela no centro da região R, e percorre-se a imagem em passos de m pixels. Para cada passo executa-se o segue procedimento: Início Gerar dois clusters baseados nos níveis de cinza da região R, usando-se o método de Otsu para computar o valor de limiarização, t, entre as duas classes no ervalo <valor global mínimo, valor global máximo>. Cluster consiste de pixels com nível de cinza l < t (Limiarização obtida utilizando-se o método de Otsu.) Cluster consiste de pixels com nível de cinza l t (Limiarização obtida utilizando-se o método de Otsu.) Se > θ A região consiste de duas classes, classificar os pixels na janela L usando a limiarização computada t. Atualizar valores para ambas as classes: C C K + K + = ωc = ωc K K + ( ω) Senão (distância muito pequena < θ) Se o valor médio é mais próximo do valor médio do background: Classificar os pixels na janela como de fundo. Atualizar valor de fundo: Se o valor médio é mais próximo do valor médio do foreground: Classificar os pixels na janela como frontais. Atualizar valor frontal: + ( ω) K + K = C + ( C ω ω) T Fim Variáveis: K + K = C + ( C ω ω) θ: Valor limite para a distância entre os valores das médias. K C i : Média atualizada da classe i. ω: Peso das médias previamente computadas. T O valor de θ deve ser escolhido dependendo do nível de ruídos contidos nas regiões homogêneas da imagem, e nas regiões de separação de classes. Quanto maiores forem as freqüências de ruídos e de variações de contraste na imagem, maiores devem ser os valores de θ. O valor de ω deve ser escolhido dependendo das variações de níveis de cinza, de cada uma das duas classes, na imagem. Quanto mais lentas forem as variações de nível de cinza, maior pode ser o valor do parâmetro ω. Os autores Eikvil aconselham usar como valores padrões da região R e dos passos L, respectivamente 5 e 3, como valor padrão de θ a ser usado 5, e como valor de ω a ser usado Conclusões

4 Pode-se concluir, analisando-se as imagens testadas, que os resultados obtidos através da limiarização de Eikvil foram satisfatórios. Apesar da implementação do algoritmo ter sido trabalhosa, e a sua performance ter sido lenta, a boa qualidade dos resultados obtidos compensam a sua utilização. Acredita-se, assim, que tem-se uma boa aplicabilidade desta técnica em imagens de documentos com variações de contraste ou com pouco contraste, causados por variações ou má iluminação. Algumas possíveis aplicações são a utilização em imagens para inspeção industrial e documentos médicos. Possíveis melhorias na técnica implementada poderiam ser feitas. O método é bem sensível à variações de contraste, sendo boa a sua performance em imagens com pouco contraste. Entretanto, em imagens com ruídos, podese dar ênfase ao ruído. Algumas considerações contextuais poderiam melhorar a performance nestes casos. Os testes realizados para classificação das sub-imagens em uma ou duas classes poderia ser melhorado, utilizando-se mais testes de modelo estatístico. Deve-se, no entanto, levar em consideração que alterações no algoritmo devem ser balanceadas contra um maior esforço computacional. 5. Referências L.Eikvil, T. Taxt & K. Moen. A Fast Adaptive Method for Binarization of Document Images, Proc First Int l Conf Document Analysis and Recognition, Sa Malo, France, pp , 99.

5 6. Implementação A implementação do algoritmo de Eikvil foi feita utilizando-se a plataforma de programação Microsoft Visual C A execução do programa ficou um pouco lenta (para algumas imagens chega a demorar alguns minutos), pois é necessário avaliar muitas janelas, dentro da própria imagem. Foi construída uma função auxiliar para o cálculo do limiar por OTSU das janelas na imagem. Esta função também calcula as médias da janela. Os valores padrões da região R e dos passos L, foram respectivamente 5 e 3. O valor padrão de θ utilizado foi 5, e o valor de ω foi 0.9, pois desta forma encontraram-se resultados satisfatórios em todas as imagens testadas. Os valores destes parâmetros podem ser alterados pelo usuário do programa. À seguir tem-se a listagem das principais funções utilizadas para se efetuar a limiarização pelo método de Eikvil. Funções implementadas na classe CpdiBase: unsigned Otsu(CPdiBase* Img, cini, lini, cfim, lfim,double* Media,double* Media,double* MediaTotal, gmin, gmax) unsigned uilimiar, i, r; long histo[56]; long k, ltotalpontos,sposicao;; lin, col; double Soma,Soma; long DWORD BYTE* Width,Height; LinBytes; lptemp; // Informacoes da Imagem Width = Img->GetWidth(); Height = Img->GetHeight(); lptemp = Img->lpBits; LinBytes = Img->bmWidthBytes; // Zera Histograma for (sposicao = gmin; sposicao < gmax+; sposicao++) histo[sposicao] = 0; // Calculo do Histograma lptemp += (long)lini*linbytes; for (lin = lini; lin <= () lfim;lin++,lptemp+=linbytes) for (col = cini; col <= () cfim; col++) histo[()lptemp[col]]++; // Comeco do cálculo do Limiar de Otsu // Aloca as Matrizes double proba[56], fomega[56], fmi[56], fsigmab[56], fsigmabmax, fmitotal; // calculo das probabilidades a priori ltotalpontos = (long) ((cfim-cini)+) * ((lfim-lini)+); for (i = gmin; i < gmax+; i++) proba[i] = (double) (histo[i])/ltotalpontos; fomega[i] = 0.0; fmi[i] = 0.0;

6 for (k = gmin; k < gmax+; k++) for (i = gmin; i < k; i++) fomega[k] += proba[i]; for (k = gmin; k < gmax+; k++) for (i = gmin; i < k; i++) fmi[k] += (i + ) * proba[i]; fmitotal = fsigmabmax = 0.0; for (i = gmin; i < gmax+; i++) fmitotal += (i + ) * proba[i]; if ((fomega[0] * ( - fomega[0]))!= 0.0) fsigmabmax = ( (fmitotal * fomega[0] - fmi[0]) * (fmitotal * fomega[0] - fmi[0]) ) / (fomega[0] * ( - fomega[0])); uilimiar = 0; for (k = gmin; k < gmax+; k++) if ((fomega[k] * ( - fomega[k]))!= 0.0) fsigmab[k] = ( (fmitotal * fomega[k] - fmi[k]) * (fmitotal * fomega[k] - fmi[k]) ) / (fomega[k] * ( - fomega[k])); if (fsigmab[k] >= fsigmabmax) fsigmabmax = fsigmab[k]; uilimiar = (unsigned ) k; // Final do cálculo do Limiar de Otsu // Calculo de mi *Media = 0; Soma = 0; for(k=gmin;k < uilimiar;k++) (*Media) += k*histo[k]; Soma += histo[k]; // Calculo de mi *Media = 0; Soma = 0; for(k=uilimiar;k < gmax+;k++) (*Media) += k*histo[k]; Soma += histo[k];

7 *MediaTotal = (*Media + *Media)/(Soma+Soma); if (Soma!= 0) *Media = *Media / Soma; else *Media = -; // mi inexistente if (Soma!= 0) *Media = *Media / Soma; else *Media = -; // mi inexistente return uilimiar; void CPdiBase::LimiarEikvil(CPdiBase* Img, n, m, Teta,double Omega) data; n6,m6; i,j,l; lin,col ; linx,colx ; cinir,linir,cfimr,lfimr; cinil,linil,cfiml,lfiml; unsigned LOtsu,LEikvil; long Width,Height; double mi,mi,mit; double Cb,Cb; long LinBytes; BYTE* lptemp ; // Informacoes da Imagem Width = GetWidth(); Height = GetHeight(); LinBytes = bmwidthbytes; n6 = n/; m6 = m/; gmax = 0; gmin = 55; // Calculo de gmax e gmim // Este valores limitam os cálculos dos reais niveis de cinza lptemp = lpbits; for(lin=0;lin<height;lin++,lptemp+=linbytes) for(col=0;col<width;col++) data = ()lptemp[col]; if (data > gmax) gmax = data; if (data < gmin) gmin = data;

8 Cb=0; Cb=0; for (lin = 0;lin < Height-m;lin+=m) for (col = 0;col < Width-m;col+=m) cinir = col+m6-n6; cfimr = col+m6+n6; linir = lin+m6-n6; lfimr = lin+m6+n6; cinil = col+0; cfiml = col+m; linil = lin+0; lfiml = lin+m; da imagem da imagem imagem imagem da imagem da imagem imagem imagem if (cinir < 0) cinir = 0; if (linir < 0) // Caso coluna da Janela fora // Caso linha da Janela fora linir = 0; if (cfimr > Width -) // Caso coluna da Janela fora da cfimr = Width -; if (lfimr > Height-) // Caso linha da Janela fora da lfimr = Height-; if (cinil < 0) cinil = 0; if (linil < 0) // Caso coluna da Janela fora // Caso linha da Janela fora linil = 0; if (cfiml > Width -) // Caso coluna da Janela fora da cfiml = Width -; if (lfiml > Height-) // Caso linha da Janela fora da lfiml = Height-; ) LOtsu=Otsu(Img,ciniR,liniR,cfimR,lfimR,&mi,&mi,&miT,gMin,gMax); <= fabs(mi-lotsu))) ) lptemp = lpbits; lptemp += linil*linbytes; // Algoritmo propriamente dito if ( (mi == -) (mi == -) (fabs(mi - mi) <= Teta) if ( (mi == -) ((mi!= -) && (fabs(mi-lotsu) // Classificar os pixels na janela // local como foreground. Cb = Omega*Cb + (-Omega)*miT;

9 for (linx = linil;linx < lfiml;linx++,lptemp+=linbytes) for (colx = cinil;colx < cfiml;colx++) data = lptemp[colx]; lptemp[colx] = (data < Cb)? 0 : 55; // lptemp[colx] = 0; <= fabs(mi-lotsu))) ) if ( (mi == -) ((mi!= -) && (fabs(mi-lotsu) // Classificar os pixels na janela // local como background. Cb = Omega*Cb + (-Omega)*miT; for (linx = linil;linx < lfiml;linx++,lptemp+=linbytes) for (colx = cinil;colx < cfiml;colx++) data = lptemp[colx]; lptemp[colx] = (data < Cb)? 0 : 55; // lptemp[colx] = 55; else if ( (fabs(mi - mi) > Teta) ) // Classificar os pixels na janela local,l, // usando o valor de limiar t. for (linx = linil;linx < lfiml;linx++,lptemp+=linbytes) for (colx = cinil;colx < cfiml;colx++) data = lptemp[colx]; lptemp[colx] = (data < LOtsu)? 0 : 55; Cb = Omega*Cb + (-Omega)*mi; Cb = Omega*Cb + (-Omega)*mi; Implementação da janela de seleção dos parâmetros do algoritmo de Eikvil: // DlgEikvil.cpp : implementation file // #include "stdafx.h"

10 #include "pdimagem.h" #include "DlgEikvil.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = FILE ; #endif ///////////////////////////////////////////////////////////////////////////// // CDlgEikvil dialog CDlgEikvil::CDlgEikvil(CWnd* pparent /*=NULL*/) : CDialog(CDlgEikvil::IDD, pparent) //AFX_DATA_INIT(CDlgEikvil) m_janl = 3; m_janr = 5; m_omega = 0.9; m_teta = 5; //AFX_DATA_INIT void CDlgEikvil::DoDataExchange(CDataExchange* pdx) CDialog::DoDataExchange(pDX); //AFX_DATA_MAP(CDlgEikvil) DDX_Text(pDX, IDC_JANL, m_janl); DDX_Text(pDX, IDC_JANR, m_janr); DDX_Text(pDX, IDC_OMEGA, m_omega); DDX_Text(pDX, IDC_TETA, m_teta); //AFX_DATA_MAP BEGIN_MESSAGE_MAP(CDlgEikvil, CDialog) //AFX_MSG_MAP(CDlgEikvil) //AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// // CDlgEikvil message handlers void CDlgEikvil::OnOK() UpdateData(TRUE); if (m_janr < m_janl) AfxMessageBox("O Tamanho da Janela-R deve ser\nmaior ou igual que o da Janela-L!"); return; if ( (m_janl% == 0) (m_janr% == 0) ) AfxMessageBox("O Tamanho das Janelas deve ser\nimpar para facilitar os cálculo!"); return;

11 if (!( (m_omega > 0) && (m_omega < ) ) ) AfxMessageBox("O Valor de Omega deve\npertencer ao ervalo ]0,[!"); return; if ( (m_teta < 5) (m_teta > 0) ) AfxMessageBox("O Valor de Teta deve\npertencer ao ervalo [5,0]!"); return; 3!"); if ( (m_janl < 3) (m_janr < 3) ) AfxMessageBox("O Tamanho das Janelas deve ser maior ou igual a return; CDialog::OnOK();