PROF. DR. JACQUES FACON MORFOLOGIA MATEMÁTICA FUZZY : ESTUDO COMPARATIVO

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 MORFOLOGIA MATEMÁTICA FUZZY : ESTUDO COMPARATIVO Resumo: A teoria dos conjuntos Fuzzy tem uma promissora aplicação no processamento de imagens. A tecnologia na área de imagens está sempre em crescimento e possui infinitas aplicações. Este trabalho mostra um estudo feito sobre a Morfologia Fuzzy, algumas abordagens Fuzzy e como estas abordagens foram implementadas e aplicadas no processamento de imagens. As definições Fuzzy utilizadas estão descritas assim como também é tratado sobre o Elemento Estruturante e apresentado os tipos utilizados. Palavras-chave: Morfologia Matemática, Morfologia Fuzzy, Elemento Estruturante, níveis de cinza, Erosão, Dilatação. Abstract: Fuzzy set theory has a promising application in the image processing. The technology in this area of images is always in increase and this area has infinite applications. This paper shows a study about Fuzzy Morphology, some Fuzzy definitions and how them were implemented and applyed in the image processing. The fuzzy definitions and the Structuring Element used are described. Key-words: Mathematical Morphology, Fuzzy Morphology, Structuring Element, greyvalues, Erosion, Dilation. 1. Introdução O objetivo deste trabalho é estudar a Morfologia Fuzzy e implementar algumas abordagens fuzzy e aplicar no processamento de imagens. Atualmente cada vez mais manipulação, tratamento e armazenamento de informações diversas e complexas são necessárias. Um tipo de informação muito usado e muito significante é a imagem, basta lembrar que uma imagem traz uma quantidade enorme de informações, podemos citar como exemplo um gráfico de custos, uma imagem médica sobre uma área doente de algum órgão e outras. Esta área de processamento de imagens está em constante evolução tecnologia e possui inúmeras aplicações.

2 Na seção 2 teremos uma visão geral do sistema falando sobre a teoria fuzzy e a descrição funcional do sistema, na 3 serão discutidos alguns tópicos da implementação, e na seção 4 temos as conclusões. 2. Visão Geral do Sistema Conceitos da Teoria Fuzzy Na teoria dos conjuntos fuzzy a intersecção e a união são definidos por uma família de operadores chamados de t-normas e t-conormas respectivamente. As definições de erosão e dilatação usam a intersecção e a união para definir erosão e dilatação fuzzy, e se encontram definidas na literatura várias definições para esses conceitos, as t- normas e as t-conormas. A seguir serão apresentadas algumas definições encontradas na literatura para dilatação e erosão fuzzy e nas quais foram baseados os algoritmos desenvolvidos neste projeto. Definição 1: D1 v (µ)(x) = sup min[µ(y), v(y x)], E1 v (µ)(x) = inf max[µ(y), 1 - v(y x)]. Definição 2: D2 v (µ)(x) = sup [µ(y)*v(y x)], E2 v (µ)(x) = inf[µ(y)*v(y x) v(y x)]. Definição 3: D3 v (µ)(x) = sup max[0, µ(y) + v(y x) - 1], E3 v (µ)(x) = inf min [1, 1 + µ(y) - v(y x)]. Definição 4: D4 v (µ)(x) = sup max[0, 1 - λ(µ(y)) - λ(v(y x))], E4 v (µ)(x) = inf min[1, λ(1 - µ(y)) + λ(v(y x))], sendo que λ é uma função definida de [0,1] 3 [0,1] e que obedece a algumas propriedades. E o valor de λ é calculado por: λ = 1 x. Descrição geral do Sistema

3 O usuário escolhe uma das imagens disponíveis no banco de imagens e entra com as informações necessárias para a execução do algoritmo. As informações necessárias são escolhidas pelo usuário, e são elas: se será uma operação de erosão ou dilatação, a definição que será utilizada, o elemento estruturante, o tamanho do elemento estruturante e o valor do corte alfa. O sistema verifica a imagem e as informações escolhidas. Caso ocorra algum problema uma mensagem é emitida e se estiver tudo correto os dados são passados para a execução do algoritmo. A nova imagem produzida é exibida na tela para o usuário e caso ocorra algum erro uma mensagem é emitida. Software utilizado Este projeto foi desenvolvido no compilador Visual C da Microsoft utilizando a linguagem de programação C++. Utilizando no desenvolvimento o ambiente Windows 98 que é o mesmo ambiente de utilização da ferramenta a ser desenvolvida. 3. Pontos Importantes da Implementação Cada definição possui uma regra para a erosão e uma para a dilatação, estas regras são denominadas T-conorma no caso da erosão e T-norma no caso da dilatação. Antes da execução do algoritmo fuzzy o Elemento Estruturante é calculado. O cálculo do Elemento Estruturante é feito em função do seu tipo, tamanho e valor do corte alfa. O corte alfa é um valor de nível de cinza que varia de 0 a 255, sendo que o 0 corresponde a cor preta e o 255 corresponde a cor branca. Quando o usuário define o valor do corte alfa ele limita qual será o maior valor de nível de cinza utilizado no Elemento Estruturante. O Elemento Estruturante é representado em uma matriz. Os Elementos Estruturantes disponíveis no sistema são: Gaussiano, é calculado sobre a equação de Gauss. Os maiores níveis de cinza ficam na borda e vão diminuindo em direção do centro, o menor nível de cinza fica o centro da matriz. Parabólico, é calculado sobre a equação da parábola. O maior nível de cinza fica no centro e os valores vão diminuindo em direção à borda. Trapezoidal tem o formato de um trapézio. Retangular é como se fosse um plano e todas as posições da matriz possuem o mesmo nível de cinza. Depois que o Elemento Estruturante é calculado a imagem é varrida e um novo valor de nível de cinza é calculado para cada posição de pixel da imagem. O cálculo é feito utilizando os valores da matriz do Elemento Estruturante, o nível de cinza do pixels da imagem original e uma t-norma ou t-conorma (figura 1).

4 figura 1: Janela de escolha do do Elemento Estruturante 4. Conclusão Quanto ao desempenho do sistema obteve-se um bom resultado na utilização da Morfologia Fuzzy no tratamento de imagens. 5. Referências Bibliográficas [FACO-96] Facon J., "A Morfologia Matemática: Teoria e Exemplos", outubro [BLOC-95] Bloch I. and Maître H., "Fuzzy Mathematical Morphologies: A Comparative Study", Pattern Recognition vol 28, No 9, pp , [GROS-96] Grossert S. and Köppen M. and Nickolay B.,"A new Approach to Fuzzy Mathematical Morphology based on Fuzzy Integral and Its Application in Image Processing", Proceedings of ICPR 96, pp , [POPO-96] Popov A. T., "Fuzzy Morphology and Fuzzy Conexity Measures", Proceedings of ICPR 96, pp , 1996.

5 ////////////////////////////////////////////////////////////////////////////// /// ////////////////////////////////////////////////////////////////////////////// /// //FUNÇÕES PARA MORFOLOGIA FUZZY ////////////////////////////////////////////////////////////////////////////// /// ////////////////////////////////////////////////////////////////////////////// /// CPdimagemDoc* CPdiBase::ErosaoFuzzy(CPdimagemDoc* m_pdo_aux, CPdimagemDoc* m_pdo,int tamanhoee, BYTE cortealfa, WORD tipo_t_conorm, WORD tipo_elemento_estruturante) SetMatrizEE(tamanhoEE,tipo_elemento_estruturante, cortealfa); BYTE n_cinzateste = 0; BYTE n_cinzaee = 0; BYTE n_cinzaimg = 0; int xx, yy,k; COLORREF p1, p2; BYTE valor_pixel, valor; COLORREF val_pixel; DWORD lin, col; int s = NULL; if(tamanhoee == 9) s = 1; else if(tamanhoee == 25) s = 2; else if(tamanhoee = 49) s = 3; else if(tamanhoee = 81) s = 4; int linhas = (int) GetHeight(); int colunas = (int) GetWidth(); for(lin = s; lin < linhas-1-s; lin ++)//pega o comprimento da imagem retirando as bordas for(col = s; col < colunas-1-s; col ++)//pega a largura da imagem retirando as bordas valor_pixel = 255;

6 for(k = 0; k < tamanhoee ; k++) xx = suporte_x[k]; yy = suporte_y[k]; GetBValue(p1)) / 3; p1 = m_pdo_aux->imagem.getpixel(col+xx,lin+yy); n_cinzaimg = (GetRValue(p1) + GetGValue(p1) + n_cinzaee = m_arrayee[xx+s][yy+s]; n_cinzaee = n_cinzaee; tipo_t_conorm); valor = T_Conorma(n_cinzaImg, n_cinzaee, valor_pixel = minimo(valor_pixel, valor); val_pixel = RGB(valor_pixel,valor_pixel,valor_pixel); m_pdo->imagem.setpixel(col, lin, val_pixel); m_pdo_aux->imagem.hdib = m_pdo->imagem.copyhandle(); return m_pdo; CPdimagemDoc* CPdiBase::DilatacaoFuzzy(CPdimagemDoc* m_pdo_aux, CPdimagemDoc* m_pdo, int tamanhoee, BYTE cortealfa, WORD tipo_t_norm, WORD tipo_elemento_estruturante) SetMatrizEE(tamanhoEE,tipo_elemento_estruturante, cortealfa); BYTE n_cinzaee = 0; BYTE n_cinzaimg = 0; int xx, yy, k; COLORREF p1; BYTE valor_pixel, valor; COLORREF val_pixel; DWORD lin, col; int s = NULL; if(tamanhoee == 9) s = 1; else if(tamanhoee == 25) s = 2; else if(tamanhoee = 49) s = 3; else if(tamanhoee = 81)

7 s = 4; int linhas = (int) GetHeight(); int colunas = (int) GetWidth(); for(lin = s; lin < linhas-1-s; lin ++)//pega o comprimento da imagem retirando as bordas for(col = s; col < colunas-1-s; col ++)//pega a largura da imagem retirando as bordas valor_pixel = 0; for(k=0; k<tamanhoee; k++) xx = suporte_x[k]; yy = suporte_y[k]; GetBValue(p1)) / 3; p1 = m_pdo_aux->imagem.getpixel(col+xx,lin+yy); n_cinzaimg = (GetRValue(p1) + GetGValue(p1) + n_cinzaee = m_arrayee[xx+s][yy+s]; valor = T_Norma(n_cinzaImg, n_cinzaee, tipo_t_norm); valor_pixel = maximo(valor_pixel, valor); val_pixel = RGB(valor_pixel,valor_pixel,valor_pixel); m_pdo->imagem.setpixel(col, lin, val_pixel); m_pdo_aux->imagem.hdib = m_pdo->imagem.copyhandle(); return m_pdo; void CPdiBase::SetMatrizEE(int& tamanhoee, WORD& tipo_elemento_estruturante, BYTE& cortealfa) float div = NULL; float p1 = NULL; float tmp = NULL; int x = 0; int y = 0; int n = 0; int raiz = 0; if(tamanhoee == 9) p1 = 1; else if(tamanhoee == 25)

8 p1 = 2; else if(tamanhoee = 49) p1 = 3; else if(tamanhoee = 81) p1 = 4; for(x=0; x < 81; x++) suporte_x[x] = 0; suporte_y[x] = 0; for(x = 0; x < 9; x++) for(y = 0; y < 9; y++) m_arrayee[x][y] = 0; raiz = (int)(sqrt((double)(tamanhoee))); for(int i = 0; i < raiz; i++) for(int j = 0; j < raiz; j++) suporte_x[n] = (int)(j-p1); suporte_y[n] = (int)(i-p1); n++; if(tipo_elemento_estruturante == PARABOLOIDE) int aux = 0; for(y = 0; y < raiz; y++) for(x = 0; x < raiz; x++) tmp = (float)((suporte_x[aux]*suporte_x[aux]) + (suporte_y[aux]*suporte_y[aux])); div = (float)((tmp)/(p1*p1)); if(div <= 2.0) m_arrayee[x][y] = (BYTE)(cortealfa * div/2.0); aux++;

9 else if(tipo_elemento_estruturante == GAUSSIANO) int aux = 0; float n_cinza = NULL; float maior_geral = 0.0; float menor_geral = ; float sigma_x = p1; float sigma_y = p1; float sigma = NULL; float expoente = NULL; float X = NULL; float Y = NULL; for(y = 0; y < raiz; y++) for(x = 0; x < raiz; x++) X = (float)(abs(suporte_x[aux])); Y = (float)(abs(suporte_y[aux])); sigma = (float)(sqrt(pow(sigma_x,2) + pow(sigma_y,2))); expoente = ((-1.0/2.0) * (X/p1)) - ((1.0/2.0) * (Y/p1)); tmp = (float)(1.0/sigma*((float)(sqrt(2*pi)))) * (float)(pow(e,expoente)); maior_geral = maximo(maior_geral,tmp); menor_geral = minimo(menor_geral,tmp); aux++; //calcula maior valor entre os elementos do EE. aux = 0; for(y = 0; y < raiz; y++) for(x = 0; x < raiz; x++) X = (float)(abs(suporte_x[aux])); Y = (float)(abs(suporte_y[aux])); sigma = (float)(sqrt((float)(pow(sigma_x,2)) + (float)(pow(sigma_y,2)))); expoente = ((-1.0/2.0) * (X/p1)) - ((1.0/2.0) * (Y/p1)); tmp = (float)(1.0/sigma*((float)(sqrt(2*numpi)))) * (float)(pow(e,expoente)); n_cinza = (tmp-menor_geral)/(maior_geral-menor_geral); m_arrayee[x][y] = (BYTE)((cortealfa*n_cinza)); aux++; else if(tipo_elemento_estruturante == RETANGULAR)

10 int aux = 0; for(y = 0; y < raiz; y++) for(x = 0; x < raiz; x++) m_arrayee[x][y] = (BYTE)(cortealfa); else if(tipo_elemento_estruturante == TRAPEZOIDAL) int aux = 0; float p2 = p1; p1 = p1/2; for(y = 0; y < raiz; y++) for(x = 0; x < raiz; x++) tmp = (float)(abs(suporte_x[aux])); tmp = (float)((abs(suporte_y[aux]) > (tmp))? (abs(suporte_y[aux])) : (tmp)); if(tmp < p1) m_arrayee[x][y] = (BYTE)(cortealfa); else tmp = tmp - p2/p1; if(tmp < 1.0) tmp = cortealfa * tmp; m_arrayee[x][y] = (BYTE)((tmp > cortealfa? cortealfa : tmp)); aux++; BYTE CPdiBase::T_Conorma(BYTE x, BYTE y, WORD tipo) BYTE z; double zz, xx, yy; xx = (double)(x); yy = (double)(y); switch(tipo) case ZADEH: z = (BYTE)(maximo(xx, yy));

11 case PROBABILISTICA: z = (BYTE)((xx)+(yy)-(xx)*(yy)/255); case LUKASIEWICZ: zz = xx + yy; z = (BYTE)(minimo(zz, 255.0)); case DEFINICAO5: xx = xx/255.0; yy = yy/255.0; zz = (((3.0 * xx) - (3.0 * xx*xx) + (xx*xx*xx)) + ((3.0 * yy) - (3.0 * yy*yy) + (yy*yy*yy))) * 255.0; z = (BYTE)(minimo(zz, 255)); case BLOCHMAITRE: return z; BYTE CPdiBase::T_Norma(BYTE x, BYTE y, WORD tipo) BYTE z; double zz, xx, yy; xx = (double)(x); yy = (double)(y); switch(tipo) case ZADEH: z = (BYTE)(minimo(xx, yy)); case PROBABILISTICA: z = (BYTE)((xx)*(yy)/255.0); case LUKASIEWICZ: zz = xx + yy - 255; z = (BYTE)(maximo(zz, 0)); case DEFINICAO5: xx = xx/255.0; yy = yy/255.0; zz = (pow(xx,3) + pow(yy, 3) ) * 255.0; z = (BYTE)(maximo(zz, 0));

12 case BLOCHMAITRE: return(z);