RECONHECIMENTO DE OBJETOS GEOMÉTRICOS EM IMAGENS

Transcrição

1 UNIVERSIDADE FEDERAL DE SANTA CATARINA CENTRO TECNOLÓGICO DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA CURSO DE CIÊNCIAS DA COMPUTAÇÃO RECONHECIMENTO DE OBJETOS GEOMÉTRICOS EM IMAGENS Flavio da Silveira Pepino Florianópolis -SC 2008/2

2 Flavio da Silveira Pepino Reconhecimento de objetos geométricos em imagens Trabalho de Conclusão de Curso Curso submetido à Universidade Federal de Santa Catarina como parte dos requisitos para a obtenção do grau de Bacharel em Ciências da Computação Orientador: Professor Doutor Mauro Roisenberg BACHARELADO EM CIÊNCIAS DA COMPUTAÇÃO DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA CENTRO TECNOLÓGICO UNIVERSIDADE FEDERAL DE SANTA CATARINA Florianópolis Dezembro 2008/2

3 Agradecimentos Aos professores em todos os níveis da minha vida, aos amigos, inimigos, cachorros, gatos e outros animais. Ao pessoal da Ilha, aos colegas da UFSC, ao pessoal que conheci em Santa Catarina, são tantas pessoas. À minha família em especial e ao supremo West criador de tudo o que conhecemos =).

4 Trabalho de Conclusão de Curso apresentado sob o título de Reconhecimento de objetos geométricos em imagens, defendido por Flavio da Silveira Pepino e aprovado no dia 8 de dezembro de 2008, em Florianópolis, Santa Catarina pela banca examinadora constituída por: Prof. Mauro Roisenberg, Doutor Orientador Prof. Silvia Modesto Nassar, Doutora Universidade Federal de Santa Catarina Prof. Lúcia Helena Martins Pacheco, Doutora Universidade Federal de Santa Catarina

5 Resumo Este trabalho construiu uma simulador de visão de computador no ambiente Matlab, o simulador utiliza uma rede neural artificial para classificação de formas geométricas (círculo,quadrado, triângulo ou retângulo) presentes em uma imagem. A tarefa de reconhecimento de imagens foi dividida em duas etapas: pré-processamento e classificação através de uma rede neural. Na etapa de pré-processamento, as imagens foram processadas por um algoritmo de detecção de bordas, utilizando o algoritmo de Sobel, que elimina o fundo contra o qual a imagem se encontra, deixando apenas o contorno do objeto a ser reconhecido. Foi utilizado o algoritmo log-polar foram tornar para tornar o sistema invariante a efeitos de translação, rotação e escala. O vetor resultante foi usado como entradas para a rede neural. Na classificação foi utilizada uma rede neural artificial criada no ambiente Matlab. Duas amostras foram utilizadas para treinar a rede, e 20 (vinte) para testes para cada classe. Palavras-chaves: redes neurais artificiais, inteligência artificial

6 Abstract This work has built a computer simulation of vision of the Matlab environment, the simulator uses an artificial neural network for classification of geometric shapes (circle, square, triangle or rectangle) in an image. The task of recognition of images was divided into two stages: pre-processing and classification using a neural network. In stage pre-processing, the images were processed by an algorithm for detecting edges, using the algorithm of Sobel, which eliminates the background against which the image is, leaving only the outline of the object being recognized. Algorithm was used log-polar have been made to make the system invariant the effects of translation, rotation and scale. The resultant vector was used as inputs to the neural network. In the classification used a neural network was created in Matlab environment. Two samples were used to train the network, and 20 (twenty) for tests for each class. Keywords: artificial neural network

7 Sumário 1 Introdução Especificação do problema Objetivos Justificativa Estrutura do trabalho Fundamentação Teórica Imagem Digital Rede Neural Artificial Unidades em redes neurais artificiais Estrutura da rede Transformada Log-Polar Metodologia Aquisição de imagens Pré-processamento de imagens Classificação Resultado Conclusão...25 Referências...26 Apêndices...27 Apêndice A Código Matlab Simulador e testes...27 Anexo 1 Artigo Formato SBC...46

8 Lista de figuras Figura 1 Plano de Imagem Figura 2 Unidade em redes neurais Figura 3 Estrutura de uma rede neural artificial...14 Figura 4.Exemplo de cada classe de uma imagem original...19 Figura 5 Detecção de aresta utilizando o algoritmo de Sobel...19 Figura 6. Resultado da operação log-polar para os círculos...20 Figura 7 Resultado da operação log-polar para os retângulos...20 Figura 8 Resultado da operação log-polar para os triângulos...20 Figura 9 Resultado da operação log-polar para os quadrados...20 Figura 10 Arquitetura de RNA proposta...22 Figura 11 Treinamento da rede...23

9 Lista de Tabelas 1: Vetor de saída da RNA : 8 Vetores de saída gerados para cada exemplo no treinamento Acertos nos testes antes da Transformada de Fourier...24

10 Lista de acrônimos e abreviações RNA Rede Neural Artificial

11 8 1 Introdução Visão computacional é um sistema computadorizado capaz de adquirir, processar e interpretar imagens correspondentes a cenas reais (Filho, 1999, pg.13). Redes neurais artificiais são estruturas de dados inspiradas na estrutura e funcionamento de uma coleção de neurônios. O trabalho das redes neurais artificiais, informalmente também chamadas de redes neurais, é motivado pela forma diferente de como o computador digital funciona. O cérebro é um sistema de processamento de informação altamente complexo, não-linear e paralelo (Haykin, 2001, p. 27). Um neurônio é uma célula nervosa cuja função é coletar, processar e disseminar sinais elétricos. De uma forma simplificada, um neurônio transmite um sinal para outro neurônio da rede quando uma combinação linear de suas entradas ultrapassa um limiar. A visão humana é uma tarefa de processamento de informação cuja função é fornecer uma representação do ambiente para que possamos interagir com ele. O cérebro realiza a todo o momento tarefas de reconhecimento perceptivo (rostos, cenas) em aproximadamente ms (Haykin, 2001, p. 27), enquanto problemas de muito menor complexidade acabam por necessitar um esforço computacional elevado em um computador digital, muito além de milisegundos. De uma forma geral, uma rede neural é uma máquina que é projetada para modelar a maneira como nosso cérebro realiza uma tarefa em particular (função de interesse), e ela é implementada e executada em um computador digital. O interesse deste trabalho é em uma classe de redes neurais que realizam a computação útil através de um processo de aprendizagem. O procedimento utilizado para realizar o processo de aprendizagem é chamado de algoritmo de aprendizagem. Redes neurais têm sido utilizadas largamente em aplicações de reconhecimento de imagens devido ao seu poder de aprendizado.

12 9 1.1 Especificação do problema O problema consiste em uma imagem que contém objetos de formas geométricas - círculo, quadrado, triangulo ou retângulo. Os objetos podem estar dispostos em uma imagem em diferentes posições, rotações e escala. 1.2 Objetivos Este trabalho pretende implementar um simulador de Visão Computacional, utilizando uma rede neural artificial com a função de interesse de classificação e reconhecimento objetos geométricos com forma geométricas em imagens bidimensionais Específico Investigar e descrever a arquitetura da rede neural usado para resolver o problema. Treinar a rede neural para aprender a reconhecer os determinados objetos (círculo, quadrado, retângulo ou triângulo). 1.3 Justificativa Utilizar o conhecimento de computação e suas ferramentas no reconhecimento de formas geométricas presentes na vida cotidiano. Muitos objetos da vida real tem as mesmas formas geométricas utilizadas neste trabalho. O interesse deste trabalho é poder reconhecer as formas geométricas independente de sua posição na imagem, sua

13 10 variação em relação a rotação e sua escala. Para isso é necessário preservar as características extraídas dos objetos, mantendo assim sua integridade. 1.4 Estrutura do trabalho Os capítulos seguintes estão organizados da seguinte forma. No capítulo 2 é apresentada a fundamentação teórica do trabalho. A seção 2.1 mostra os conceitos básicos de imagens digitais, seção 2.2 apresenta os conceitos de redes neurais artificiais e sua propriedades interessantes para este trabalho. A seção 2.3 exibe a transformada de Fourier e Log-Polar. O capítulo 3 apresenta a metodologia seguida pelo trabalho, apresenta a solução proposta. O capítulo 4 comenta os resultados, e o capítulo 5 é a conclusão.

14 11 2.Fundamentação Teórica 2.1 Imagem digital Um sinal analógico de vídeo, obtido no caso por uma câmera, deve ser discretizado em relação ao seu espaço e sua amplitude para se tornar apto ao processamento digital. O modelo para lidar com imagens assume uma matriz MxN de intensidade de luz no plano de uma imagem que podemos chamar de I(x,y). O espaço está relacionado à resolução da imagem. Figura 1: Plano da imagem E a amplitude da imagem está relacionada com a quantidade de tons de cinzas. Cada posição na matriz, ou seja, cada pixel possui um valor relacionado ao tom de cinza, que pode ser um valor inteiro na faixa 0 a 2 n-1.

15 Rede Neural Artificial (RNA) Conforme Haykin (2001,pg.28), uma rede neural é um processador maciçamente paralelamente distribuído constituído de unidades de processamento simples, que têm a propensão natural para armazenar conhecimento experimental e torná-lo disponível para uso, os aspectos relevantes das RNAs relevantes para este trabalho são o processo de aprendizagem e forças de conexão entre os neurônios (chamados de pesos sinápticos), que são utilizados para armazenar o conhecimento adquirido. A alteração dos pesos sinápticos é a maneira usual para projetar redes neurais. O poder das redes neurais advém de sua estrutura paralela e sua capacidade de generalização. Generalização é a capacidade da RNA produzir saídas adequadas para entradas que não foram dadas durante o treinamento (aprendizagem). Estas duas habilidades de processamento da informação dão às RNAs possibilidade de resolver problemas complexos que são difíceis por outras abordagens. Entre as propriedades das redes neurais artificiais apresentadas por Haykin (2001) as seguintes são interessantes para o trabalho: Mapeamento de Entrada-Saída: Paradigma de aprendizado chamado aprendizagem com um professor ou aprendizagem supervisionada envolve a modificação de seus pesos sinápticos de um rede neural pela aplicação de um conjunto de amostras de treinamento rotuladas ou exemplos de tarefa. Cada exemplo consiste de um sinal de entrada único e de uma resposta desejada correspondente. Apresenta-se para rede um exemplo escolhido ao acaso do conjunto, e os pesos sinápticos (parâmetros livres) da rede são modificados para minimizar a diferença entre a resposta desejada e a resposta real da rede, produzida pelo sinal de entrada, de acordo com um critério estatístico apropriado. O treinamento da rede é repetido para muitos exemplos do conjunto até que a

16 13 rede alcance um estado estável onde não haja mudança significativa nos pesos sinápticos. Os exemplos de treinamento previamente aplicados podem ser reaplicados durante a sessão de treinamento, mas em uma ordem diferente. Assim, a rede aprende dos exemplos ao construir um mapeamento de entrada saída para o problema considerado. Adaptabilidade. As redes neurais têm a capacidade inata de adaptar seus pesos sinápticos a modificações do ambiente. Uma rede treinada para operar em um ambiente especifico pode ser facilmente retreinada para lidar com pequenas modificações nas condições operativas do ambiente Unidades em Rede Neurais As redes neurais são compostas de nós ou unidades conectadas por vínculos orientados para o corpo. Um vínculo da unidade i para unidade j serve para propagar a ativação xn desde i até j. Cada vínculo também tem um peso numérico Wi,j associado a ele, o qual determina a intensidade e o sinal de conexão, também chamada de peso sináptico.

17 14 Figura 2: Unidade rede neural artificial Estrutura da rede Existem duas categorias principais de redes neurais: redes acíclicas ou ou redes de alimentação direta e redes ciclícas ou recorrentes. Para este trabalhos estamos interessados em redes de alimentação direta devido que uma rede de alimentação direta representa uma função de sua entrada atual, logo não tem nenhum estado interno além dos pesos propriamente ditos (Norvig, 2001,pg.715). Figura 3: Estrutura de RNA com uma camada oculta.

18 15 Expressa-se a a saída da camada oculta como função de suas entradas e então a saída da rede é função das entradas da rede como um todo. Os pesos sinápticos do neurônios funcionam como parâmetros dessa função, a alteração nos pesos sinápticos altera a função que a rede representa e isso é o processo de aprendizagem. Uma rede neural pode ser usada para classificação ou regressão. O aprendizado supervisionado ou classificação de padrões oferece uma estrutura natural para o estudo do reconhecimento de objetos. As redes de alimentação de direta se dispõem em camadas, cada unidade recebe somente a entrada de camadas situadas na camada predecessora. É possível redes de alimentação direta com uma única camada onde todas entradas estão ligadas diretamente a saída, o chamado perceptron. Os perceptrons têm um poder de expressão limitado. Para este trabalho estamos interessados em redes de alimentação direta com uma camada oculta pois aumenta o espaço de hipóteses que a rede pode representar. 2.3 Transformada de Fourier, Log-polar Uma das ferramentas mais utilizadas no processamento de imagens é a transformada de Fourier, que permite obter uma visão da imagem a ser analisada no domínio da freqüência, facilitando a análise e o seu processamento. Em computadores utiliza-se os algoritmos para execução rápida das transformadas de Fourier (FFT). Um sinal no domínio do tempo é representado é muito comum no ensino mas em determinados casos é mais útil a representação de no domínio da freqüência, e esta operação de transformação é feita pela Transformadas de Fourier. A premissa da transformada de Fourier assume que o sinal é contínuo com uma extensão infinita, para o qual a transformada é desejada. Mas imagens são muitas vezes descontínuas ao longo de uma linha ou coluna da imagem. Para analisar dados de pixel de uma imagem contínua a versão discreta de transformada de Fourier foi desenvolvida e foi chamada de transformada rápida de Fourier (FFT). Esta implementação é a base para a maioria de algoritmos de processamento de imagens usando transformada de Fourier.

19 16 A mudança de domínio garante certas propriedades interessantes para este trabalho como em relação à translação e à rotação, pois a transformada possui as características de separabilidade e independência das freqüências associadas às respectivas direções espaciais. Um imagem pode ser representada por uma transformada de Fourier bi-dimensional, a qual pode ser considerada como uma imagem com uma parte real e uma parte complexa. A transformada de Fourier em duas dimensões monta um mapa de valores de pixel de imagem no espaço de freqüência da imagem espacial. Utilizando o algoritmo da Transformada Rápida de Fourier em duas dimensões em uma imagem, monta-se um mapeamento de todas as freqüências de espaço dentro de uma imagem. A Transfomada de Fourier (FT) é decompõe um sinal em suas componentes elementares seno e cosseno. A FT aplicada a uma imagem no domínio espacial gera uma informação no domínio da freqüência, em que cada ponto, definido por um vetor do tipo (k.cosseno, k.seno), representa uma dada freqüência contida no domínio espacial da imagem. A amplitude da TF de f(x,y) permanece invariante à translações, o que é útil para este trabalho. Mudanças de escala e rotações, no entanto, não são invariantes na TF e nem em sua amplitude espectral, o mesmo ocorrendo na TF discreta. A transformada log-polar (LP) é uma TF bidimensional associada a uma troca de sistemas de coordenadas: em lugar do par (u,v) utilizado em (1) usa-se a representação (ρ,θ), onde e ρ é o raio polar e θ o ângulo. A troca de coordenadas é dada por u = (1) v = e e ρ ρ cos θ sen θ e difere da representação polar usual por considerar e ρ como o raio polar. A troca de sistemas de coordenadas de representação para freqüências aplicada na TF define a transformação LP através de lp( f )( ρ, θ ) = LP( f )( ρ, θ ) LP( f )( ).

20 Observa-se que a transformação LP-normalizada, como a TF, é invariante sob translação Metodologia

21 18 Para obter a visão um computador precisa transformar a imagem para que ela se torne apta para seu reconhecimento. É necessário também extrair características que possam ser invariantes do objeto independendo da disposição do objeto na imagem. Foi utilizado o ambiente de computação Matlab nos experimentos, incluindo o Toolbox de Redes Neurais e Processamento de Imagens. 3.1 Aquisição das imagens O simulador de visão computacional busca reconhecer os objetos geométricos de diferentes formas através da rede neural artificial em qualquer posição da imagem e diferentes escalas e rotações. Foram escolhidas 4 classes para buscar essa função de interesse: quadrado, circulo, triangulo e retângulo Pré-processamento da imagem Eleitos então objetos, foi necessário estudar suas características que possam ser usadas para seu reconhecimento. Primeiro, é necessário operação de baixo nível para detectar arestas no plano de imagem. Arestas são linhas que no plano da imagem, ao longo dos quais existe uma mudança significativa no brilho da imagem. A detecção das arestas serve para diminuir a amplitude do tom de cinza de cada pixel da matriz. Outra utilidade das arestas é que dentro de faixa adequada de contrastes, as arestas serão detectadas aproximadamente nas mesmas posições, independente da configuração precisa da iluminação. O pré-processamento da imagem foi indispensável pois reteve as características identificadoras do objeto e contribui para diminui a dimensões da entrada da RNA. Foi utilizado o método de detecção de arestas (bordas) de Sobel pois era necessário obter apenas a forma do objeto a ser identificado. As imagens no seus tamanhos originais são de 256 pixels X 256 pixels. O sistema de visão computacional deve classificar o objeto corretamente independe de seu tamanho, rotação e posição na imagem. Portanto foi utilizada a tranformada Log-

22 19 polar que torna o sistema invariante tamanho, rotação e escala. A matriz resultante da operação Log-Polar de cada imagem tinha dimensões de 64 linhas por 15 colunas. Figura 4. Exemplo de cada classe de uma imagem original. Figura 5. Detecção de arestas usando o algoritmo de Sobel.

23 20 Nas figuras a seguir vemos o resultado da operação log-polar para cada exemplo, em cada figura vemos o par de treinamento. O padrão pode ser usado como entrada na rede neural. Figura 6: Padrão resultante da operação log-polar para os círculos Figura 7: Resultado operação log-polar retângulos Figura 8: Resultado da operação log-polar para os triângulos Figura 9: Resultado operação log-polar dos quadrados

24 Classificação Dado um conjunto de pares entrada-saída, cada par consiste em em um sinal de entrada e a resposta desejada correspondente, o projeto de uma rede neural deve seguir as seguintes recomendações : A arquitetura apropriada deve ter uma camada de entrada com número de nós igual ao número de pixels que a imagem de entrada. E a camada de saída igual ao número de classes a reconhecer. Um subconjunto de exemplos é utilizado para treinar a rede por meio de um algoritmo apropriado (Haykin, 2001, pg.50). Essa fase de qualquer projeto de rede neural artificial é conhecida pela nome de aprendizagem. O desempenho da rede deve ser testado com dados não apresentados a rede durante a aprendizagem. O desempenho da rede é então estimado comparando o reconhecimento da classe fornecida com a classe real em questão. Esta fase da rede neural é conhecida como generalização. Dadas as condições, foi criada um rede neural artificial do tipo feed-foward com 960 neurônios na camada de entrada, este número equivale ao número de pixels resultante da operação de tranformação Log-Polar. A função de ativação das camadas foi definida com Tangente Hiperbólica e o algoritmo de treinamento foi Gradient descent backpropagation com momentum e taxa adaptativa. Na camada de saída foram determinadas 4 neurônios. Foi determinada que a rede executaria os exemplos através da rede, ao ajustar os pesos de cada exemplo, o ciclo, por até 1000 ciclos ou atingisse o critério de parada de

25 22 Figura 10: Arquitetura de RNA proposta Foram utilizadas dois exemplos de cada classe, para o treinamento da rede, e 20 para os testes. As amostras para treinamento da RNA foram escolhidas ao acaso, tomadas sem qualquer conhecimento sobre os dados da amostra. Foi determinada a saída alvo da RNA de acordo com a seguinte convenção: Classe Vetor de saída (alvo) Circulo [ ] Quadrado [ ] Triângulo [ ] Retângulo [ ] Tabela 1: Vetor de saída da RNA Pela tabela acima mostra-se que dado um exemplo de uma classe um neurônio da camada de saída da rede neural artificial deve retornar um valor próximo de 1 para a classe em questão e os demais neurônios da camada de saída devem valor próximo de -1. Durante o treinamento tivemos a seguinte resposta da rede neural sobre os exemplo apresentados

26 23 Classe 2 Círculos 2 Quadrados 2 Triângulos 2 Retângulos Círculo Quadrado Triângulo Retângulo Tabela 2: 8 Vetores de saída gerados para cada exemplo no treinamento Figura 11: Treinamento da rede A rede convergiu para em 44 épocas como pode ser vista na figura.

27 24 4. Resultados Foram utilizadas 80 imagens como testes para a rede neural artificial treinada com apenas dois exemplos. Cada classe foi simulada com 20 exemplos e a rede neural artificial foi capaz de atingir uma taxa de acerto conforme a tabela abaixo. Classe Acerto % Círculo 100% Quadrado 90% Triângulo 75% Retângulo 50% Tabela 3: Acertos nos testes antes da Transformada de Fourier Os resultados mostram o problema em relação a rotação dos objetos pois com o círculo não houve qualquer erro na classificação, o problema foi resolvido com a utilização da algoritmo da transformada de Fourier nas colunas das imagens resultantes da operação Log-polar. Após a utilização do algoritmo da transformada de Fourier a rede neural artificial foi capaz de acertar em todos os exemplos dados.

28 25 5. Conclusão Neste trabalho foi possível observar a utilidade das redes neurais artificiais para reconhecimento de objetos em formas geométricas. A transformada Log-Polar fundamental para diminuir os dados da entrada da RNA de neurônios para 960 neurônios o que diminuiu a complexidade da arquitetura de rede. A importância deste trabalho é que muitos objetos na vida real têm a forma das formas geométricas utilizadas neste trabalho, podendo as redes neurais artificiais serem ótimas opções para o reconhecimento e classificação de objetos do mundo real dado um padrão de dados correto.

29 26 Referências bibliográficas HAYKIN, Simon. Redes Neurais: Principios e prática. 2ª Edição. Porto Alegre: Bookman, RUSSEL, Stuart; NORVIG, Peter. Inteligência Artificial: Tradução da segunda edição. Rio de Janeiro: Elsevier, NETO, Hugo Vieira; FILHO, Ogê Marques. Processamento Digital de Imagens. Rio de Janeiro: Brasport, BOW, Sing-Tze. Pattern Recognition and Image Preprocessing. DeKalb: Dekker, 2002.

30 27 Apêndice A Código Fonte do Simulador e testes Arquivo simulador.m %Le as 4 figuras usadas para o treinamento 2 círculos, 2 quadrados, triângulo 2, retângulos A1 = imread ('circulo 1.jpg','jpg'); B1 = rgb2gray(a1); C1 = edge(b1,'sobel'); polar1 = log_polar(c1); ff1=fft2(polar1); polar1=log(abs(ff1)); A2 = imread ('circulo 3.jpg','jpg'); B2 = rgb2gray(a2); C2 = edge(b2,'sobel'); polar2 = log_polar(c2); ff2=fft2(polar2); polar2=log(abs(ff2)); %quadrado A3 = imread ('quadrado.jpg','jpg'); B3 = rgb2gray(a3); C3 = edge(b3,'sobel'); polar3 = log_polar(c3); ff3=fft2(polar3); polar3=log(abs(ff3)); A4 = imread ('quadrado 2.jpg','jpg'); B4 = rgb2gray(a4); C4 = edge(b4,'sobel'); polar4 = log_polar(c4); ff4=fft2(polar4); polar4=log(abs(ff4)); % tringuglo A5 = imread ('triangulo 20.jpg','jpg'); B5 = rgb2gray (A5); C5 = edge(b5,'sobel'); polar5 = log_polar(c5); ff5=fft2(polar5); polar5 = log(abs(ff5)); A6 = imread ('triangulo 19.jpg','jpg'); B6 = rgb2gray (A6); C6 = edge (B6,'sobel'); polar6 = log_polar (C6); ff6=fft2(polar6); polar6= log(abs(ff6));

31 28 % retangulo A7 = imread ('retangulo 13.jpg','jpg'); B7 = rgb2gray (A7); C7 = edge(b7,'sobel'); polar7 = log_polar(c7); ff7=fft2(polar7); polar7=log(abs(ff7)); A8 = imread ('retangulo 8.jpg','jpg'); B8 = rgb2gray (A8); C8 =edge(b8, 'sobel'); polar8 = log_polar(c8); ff8=fft2(polar8); polar8=log(abs(ff8)); %Transforma as matrizes em vetores para entrada na rede neural P1=reshape(polar1,1,15*64); P2=reshape(polar2,1,15*64); P3=reshape(polar3,1,15*64); P4=reshape(polar4,1,15*64); P5 = reshape(polar5,1,15*64); P6 = reshape (polar6,1,15*64); P7 = reshape (polar7,1,15*64); P8 = reshape (polar8,1,15*64); P=[P1;P2;P3;P4;P5;P6;P7;P8]; P=P'; T=[ ; ; ; ; ; ; ; ]; T=T'; net=newff(minmax(p),[20 4],{'tansig','tansig'},'traingdx'); net.trainparam.epochs=1000; net.trainparam.goal=0.01; net=train(net,p,t); result=sim(net,p) TRAINGDX, Epoch 0/1000, MSE /0.01, Gradient /1e-006 TRAINGDX, Epoch 25/1000, MSE /0.01, Gradient /1e-006 TRAINGDX, Epoch 50/1000, MSE /0.01, Gradient /1e-006 TRAINGDX, Epoch 75/1000, MSE /0.01, Gradient /1e-006 TRAINGDX, Epoch 79/1000, MSE /0.01, Gradient /1e-006 TRAINGDX, Performance goal met. % OK A9 = imread ('triangulo 1.jpg','jpg'); B9 = rgb2gray(a9); C9 = edge(b9,'sobel'); polar9= log_polar(c9); ff9=fft2(polar9); polar9=log(abs(ff9)); P9=reshape(polar9,1,15*64); P9=P9';

32 29 result=sim(net,p9) %teste quadrado OK A10 = imread ('quadrado 1.jpg','jpg'); B10 = rgb2gray(a10); C10 = edge(b10,'sobel'); polar10= log_polar(c10); ff10=fft2(polar10); polar10=log(abs(ff10)); P10 = reshape(polar10,1,15*64); P10 = P10'; result = sim (net, P10) %retangulo ok A11 = imread ('retangulo 1.jpg'); B11 = rgb2gray(a11); C11 = edge(b11,'sobel'); polar11= log_polar(c11); ff11=fft2(polar11); polar11=log(abs(ff11)); P11=reshape(polar11,1,15*64); P11=P11'; result=sim(net,p11) A12 = imread ('retangulo 2.jpg'); B12 = rgb2gray(a12); C12 = edge(b12,'sobel'); polar12= log_polar(c12); ff12=fft2(polar12); polar12=log(abs(ff12)); P12=reshape(polar12,1,15*64); P12=P12'; result=sim(net,p12) A13 = imread ('triangulo 2.jpg'); B13 = rgb2gray(a13); C13 = edge(b13,'sobel'); polar13= log_polar(c13); ff13=fft2(polar13); polar13=log(abs(ff13)); P13=reshape(polar13,1,15*64); P13=P13'; result = sim(net,p13) % OK A14 = imread ('triangulo 3.jpg');

33 30 B14 = rgb2gray(a14); C14 = edge(b14,'sobel'); polar14= log_polar(c14); ff14=fft2(polar14); polar14=log(abs(ff14)); P14=reshape(polar14,1,15*64); P14=P14'; result = sim(net,p14) A15 = imread ('triangulo 4.jpg','jpg'); B15 = rgb2gray(a15); C15 = edge(b15,'sobel'); polar15= log_polar(c15); ff15=fft2(polar15); polar15=log(abs(ff15)); P15=reshape(polar15,1,15*64); P15=P15'; result = sim(net,p15) A16 = imread ('retangulo 3.jpg'); B16 = rgb2gray(a16); C16 = edge(b16,'sobel'); polar16= log_polar(c16); ff16=fft2(polar16); polar16=log(abs(ff16)); P16=reshape(polar16,1,15*64); P16=P16'; result = sim (net,p16) % OK A17 = imread ('circulo 2.jpg','jpg'); B17 = rgb2gray (A17); C17 = edge (B17,'sobel'); polar17 = log_polar (C17); ff17=fft2(polar17); polar17=log(abs(ff17)); P17 = reshape(polar17,1,15*64); P17= P17'; result = sim (net, P17) % OK A18 = imread ('circulo 4.jpg','jpg'); B18 = rgb2gray (A18); C18 = edge (B18,'sobel'); polar18 = log_polar (C18); ff18=fft2(polar18); polar18=log(abs(ff18)); P18 = reshape(polar18,1,15*64); P18= P18'; result = sim(net,p18) % A19 = imread ('retangulo 4.jpg','jpg'); B19 = rgb2gray (A19);

34 31 C19 = edge (B19,'sobel'); polar19 = log_polar (C19); ff19=fft2(polar19); polar19=log(abs(ff19)); P19 = reshape(polar19,1,15*64); P19= P19'; result = sim(net,p19) % OK A20 = imread ('retangulo 5.jpg','jpg'); B20 = rgb2gray (A20); C20 = edge (B20,'sobel'); polar20 = log_polar (C20); ff20=fft2(polar20); polar20=log(abs(ff20)); P20 = reshape(polar20,1,15*64); P20= P20'; result = sim(net,p20) % OK A20 = imread ('retangulo 6.jpg','jpg'); B20 = rgb2gray (A20); C20 = edge (B20,'sobel'); polar20 = log_polar (C20); ff20=fft2(polar20); polar20=log(abs(ff20)); P20 = reshape(polar20,1,15*64); P20= P20'; result = sim(net,p20) A21 = imread ('quadrado 3.jpg','jpg'); B21 = rgb2gray (A21); C21 = edge (B21,'sobel'); polar21 = log_polar (C21); ff21=fft2(polar21); polar21=log(abs(ff21)); P21 = reshape(polar21,1,15*64); P21= P21'; result = sim(net,p21) A22 = imread ('quadrado 4.jpg','jpg'); B22 = rgb2gray (A22); C22 = edge (B22,'sobel'); polar22 = log_polar (C22); ff22=fft2(polar22); polar22=log(abs(ff22)); P22 = reshape(polar22,1,15*64); P22= P22'; result = sim(net,p22) % OK A23 = imread ('triangulo 5.jpg','jpg'); B23 = rgb2gray (A23); C23 = edge (B23,'sobel'); polar23 = log_polar (C23); ff23=fft2(polar23);

35 32 polar23=log(abs(ff23)); P23 = reshape(polar23,1,15*64); P23= P23'; result = sim(net,p23) A24 = imread ('triangulo 6.jpg','jpg'); B24 = rgb2gray (A24); C24 = edge (B24,'sobel'); polar24 = log_polar (C24); ff24=fft2(polar24); polar24=log(abs(ff24)); P24 = reshape(polar24,1,15*64); P24= P24'; result = sim(net,p24) A25 = imread ('triangulo 7.jpg','jpg'); B25 = rgb2gray (A25); C25 = edge (B25,'sobel'); polar25 = log_polar (C25); ff25=fft2(polar25); polar25=log(abs(ff25)); P25 = reshape(polar25,1,15*64); P25= P25'; result = sim(net,p25) A26 = imread ('triangulo 8.jpg','jpg'); B26 = rgb2gray (A26); C26 = edge (B26,'sobel'); polar26 = log_polar (C26); ff26=fft2(polar26); polar26=log(abs(ff26)); P26 = reshape(polar26,1,15*64); P26= P26'; result = sim(net,p26) A27 = imread ('triangulo 9.jpg','jpg'); B27 = rgb2gray (A27); C27 = edge (B27,'sobel'); polar27 = log_polar (C27); ff27=fft2(polar27); polar27=log(abs(ff27)); P27 = reshape(polar27,1,15*64); P27= P27'; result = sim(net,p27) A28 = imread ('circulo 5.jpg','jpg'); B28 = rgb2gray (A28); C28 = edge (B28,'sobel'); polar28 = log_polar (C28); ff28=fft2(polar28); polar28=log(abs(ff28)); P28 = reshape(polar28,1,15*64); P28= P28';

36 33 result = sim(net,p28) A29 = imread ('circulo 6.jpg','jpg'); B29 = rgb2gray (A29); C29 = edge (B29,'sobel'); polar29 = log_polar (C29); ff29=fft2(polar29); polar29=log(abs(ff29)); P29 = reshape(polar29,1,15*64); P29= P29'; result = sim(net,p29) % OK A30 = imread ('circulo 7.jpg','jpg'); B30 = rgb2gray (A30); C30 = edge (B30,'sobel'); polar30 = log_polar (C30); ff30=fft2(polar30); polar30=log(abs(ff30)); P30 = reshape(polar30,1,15*64); P30= P30'; result = sim(net,p30) % A31 = imread ('circulo 8.jpg','jpg'); B31 = rgb2gray (A31); C31 = edge (B31,'sobel'); polar31 = log_polar (C31); ff31=fft2(polar31); polar31=log(abs(ff31)); P31 = reshape(polar31,1,15*64); P31= P31'; result = sim(net,p31) A32 = imread ('circulo 9.jpg','jpg'); B32 = rgb2gray (A32); C32 = edge (B32,'sobel'); polar32 = log_polar (C32); ff32=fft2(polar32); polar32=log(abs(ff32)); P32 = reshape(polar32,1,15*64); P32= P32'; result = sim(net,p32) A33 = imread ('circulo 10.jpg','jpg'); B33 = rgb2gray (A33); C33 = edge (B33,'sobel'); polar33 = log_polar (C33); ff33=fft2(polar33); polar33=log(abs(ff33)); P33 = reshape(polar33,1,15*64); P33= P33'; result = sim(net,p33) A34 = imread ('circulo 11.jpg','jpg'); B34 = rgb2gray (A34); C34 = edge (B34,'sobel');

37 34 polar34 = log_polar (C34); ff34=fft2(polar34); polar34=log(abs(ff34)); P34 = reshape(polar34,1,15*64); P34= P34'; result = sim(net,p34) A35 = imread ('circulo 12.jpg','jpg'); B35 = rgb2gray (A35); C35 = edge (B35,'sobel'); polar35 = log_polar (C35); ff35=fft2(polar35); polar35=log(abs(ff35)); P35 = reshape(polar35,1,15*64); P35= P35'; result = sim(net,p35) A36 = imread ('circulo 13.jpg','jpg'); B36 = rgb2gray (A36); C36 = edge (B36,'sobel'); polar36 = log_polar (C36); ff36=fft2(polar36); polar36=log(abs(ff36)); P36 = reshape(polar36,1,15*64); P36= P36'; result = sim(net,p36) A37 = imread ('circulo 14.jpg','jpg'); B37 = rgb2gray (A37); C37 = edge (B37,'sobel'); polar37 = log_polar (C37); ff37=fft2(polar37); polar37=log(abs(ff37)); P37 = reshape(polar37,1,15*64); P37= P37'; result = sim(net,p37) A38 = imread ('circulo 15.jpg','jpg'); B38 = rgb2gray (A38); C38 = edge (B38,'sobel'); polar38 = log_polar (C38); ff38=fft2(polar38); polar38=log(abs(ff38)); P38 = reshape(polar38,1,15*64); P38= P38'; result = sim(net,p38) A39 = imread ('circulo 16.jpg','jpg'); B39 = rgb2gray (A39); C39 = edge (B39,'sobel'); polar39 = log_polar (C39); ff39=fft2(polar39); polar39=log(abs(ff39)); P39 = reshape(polar39,1,15*64);

38 35 P39= P39'; result = sim(net,p39) A40 = imread ('circulo 17','jpg'); B40 = rgb2gray (A40); C40 = edge (B40,'sobel'); polar40 = log_polar (C40); ff40=fft2(polar40); polar40=log(abs(ff40)); P40 = reshape(polar40,1,15*64); P40= P40'; result = sim(net,p40) % A41 = imread ('quadrado 5.jpg','jpg'); B41 = rgb2gray (A41); C41 = edge (B41,'sobel'); polar41 = log_polar (C41); ff41=fft2(polar41); polar41=log(abs(ff41)); P41 = reshape(polar41,1,15*64); P41= P41'; result = sim(net,p41) A42 = imread ('quadrado 6.jpg','jpg'); B42 = rgb2gray (A42); C42 = edge (B42,'sobel'); polar42 = log_polar (C42); ff42=fft2(polar42); polar42=log(abs(ff42)); P42 = reshape(polar42,1,15*64); P42= P42'; result = sim(net,p42) A43 = imread ('quadrado 7.jpg','jpg'); B43 = rgb2gray (A43); C43 = edge (B43,'sobel'); polar43 = log_polar (C43); ff43=fft2(polar43); polar43=log(abs(ff43)); P43 = reshape(polar43,1,15*64); P43= P43'; result = sim(net,p43) A44 = imread ('quadrado 8.jpg','jpg'); B44 = rgb2gray (A44); C44 = edge (B44,'sobel'); polar44 = log_polar (C44); ff44=fft2(polar44); polar44=log(abs(ff44)); P44 = reshape(polar44,1,15*64); P44= P44'; result = sim(net,p44)

39 36 A45 = imread ('quadrado 9.jpg','jpg'); B45 = rgb2gray (A45); C45 = edge (B45,'sobel'); polar45 = log_polar (C45); ff45=fft2(polar45); polar45=log(abs(ff45)); P45 = reshape(polar45,1,15*64); P45= P45'; result = sim(net,p45) A46 = imread ('quadrado 10.jpg','jpg'); B46 = rgb2gray (A46); C46 = edge (B46,'sobel'); polar46 = log_polar (C46); ff46=fft2(polar46); polar46=log(abs(ff46)); P46 = reshape(polar46,1,15*64); P46= P46'; result = sim(net,p46) A47 = imread ('quadrado 11.jpg','jpg'); B47 = rgb2gray (A47); C47 = edge (B47,'sobel'); polar47 = log_polar (C47); ff47=fft2(polar47); polar47=log(abs(ff47)); P47 = reshape(polar47,1,15*64); P47= P47'; result = sim(net,p47) A48 = imread ('quadrado 12.jpg','jpg'); B48 = rgb2gray (A48); C48 = edge (B48,'sobel'); polar48 = log_polar (C48); ff48=fft2(polar48); polar48=log(abs(ff48)); P48 = reshape(polar48,1,15*64); P48= P48'; result = sim(net,p48) A49 = imread ('quadrado 13.jpg','jpg'); B49 = rgb2gray (A49); C49 = edge (B49,'sobel'); polar49= log_polar (C49); ff49=fft2(polar49); polar49=log(abs(ff49)); P49 = reshape(polar49,1,15*64); P49= P49'; result = sim(net,p49) A50 = imread ('quadrado 14.jpg','jpg'); B50 = rgb2gray (A50);

40 37 C50 = edge (B50,'sobel'); polar50= log_polar (C50); ff50=fft2(polar50); polar50 =log(abs(ff50)); P50 = reshape(polar50,1,15*64); P50= P50'; result = sim(net,p50) A51 = imread ('retangulo 9.jpg','jpg'); B51 = rgb2gray (A51); C51 = edge (B51,'sobel'); polar51= log_polar (C51); ff51=fft2(polar51); polar51=log(abs(ff51)); P51 = reshape(polar51,1,15*64); P51= P51'; result = sim(net,p51) A52 = imread ('retangulo 10.jpg','jpg'); B52 = rgb2gray (A52); C52 = edge (B52,'sobel'); polar52= log_polar (C52); ff52=fft2(polar52); polar52=log(abs(ff52)); P52 = reshape(polar52,1,15*64); P52= P52'; result = sim(net,p52) % OK A53 = imread ('retangulo 11.jpg','jpg'); B53 = rgb2gray (A53); C53 = edge (B53,'sobel'); polar53= log_polar (C53); ff53=fft2(polar53); polar53=log(abs(ff53)); P53 = reshape(polar53,1,15*64); P53= P53'; result = sim(net,p53) % ok A54 = imread ('retangulo 12.jpg','jpg'); B54 = rgb2gray (A54); C54 = edge (B54,'sobel'); polar54= log_polar (C54); ff54=fft2(polar54); polar54=log(abs(ff54)); P54 = reshape(polar54,1,15*64); P54= P54'; result = sim(net,p54) % ok A55 = imread ('retangulo 14.jpg','jpg'); B55 = rgb2gray (A55); C55 = edge (B55,'sobel'); polar55= log_polar (C55); ff55=fft2(polar55); polar55=log(abs(ff55));

41 38 P55 = reshape(polar55,1,15*64); P55= P55'; result = sim(net,p55) % ok A56 = imread ('retangulo 12.jpg','jpg'); B56 = rgb2gray (A56); C56 = edge (B56,'sobel'); polar56= log_polar (C56); ff56=fft2(polar56); polar56=log(abs(ff56)); P56 = reshape(polar56,1,15*64); P56= P56'; result = sim(net,p56) %ok A57 = imread ('retangulo 14.jpg','jpg'); B57 = rgb2gray (A57); C57 = edge (B57,'sobel'); polar57= log_polar (C57); ff57=fft2(polar57); polar57=log(abs(ff57)); P57 = reshape(polar57,1,15*64); P57= P57'; result = sim(net,p57) %ok A58 = imread ('retangulo 15.jpg','jpg'); B58 = rgb2gray (A58); C58 = edge (B58,'sobel'); polar58= log_polar (C58); ff58=fft2(polar58); polar58=log(abs(ff58)); P58 = reshape(polar58,1,15*64); P58= P58'; result = sim(net,p58) % ok A59 = imread ('retangulo 16.jpg','jpg'); B59 = rgb2gray (A59); C59 = edge (B59,'sobel'); polar59= log_polar (C59); ff59=fft2(polar59); polar59=log(abs(ff59)); P59 = reshape(polar59,1,15*64); P59= P59'; result = sim(net,p59) % ok A60 = imread ('retangulo 17.jpg','jpg'); B60 = rgb2gray (A60); C60 = edge (B60,'sobel'); polar60= log_polar (C60); ff60=fft2(polar60); polar60=log(abs(ff60)); P60 = reshape(polar60,1,15*64);

42 39 P60= P60'; result = sim(net,p60) A61 = imread ('retangulo 18.jpg','jpg'); B61 = rgb2gray (A61); C61 = edge (B61,'sobel'); polar61= log_polar (C61); ff61=fft2(polar61); polar61=log(abs(ff61)); P61 = reshape(polar61,1,15*64); P61= P61'; result = sim(net,p61) A62 = imread ('retangulo 19.jpg','jpg'); B62 = rgb2gray (A62); C62 = edge (B62,'sobel'); polar62= log_polar (C62); ff62=fft2(polar62); polar62=log(abs(ff62)); P62 = reshape(polar62,1,15*64); P62= P62'; result = sim(net,p62) % OK A63 = imread ('retangulo 20.jpg','jpg'); B63 = rgb2gray (A63); C63 = edge (B63,'sobel'); polar63= log_polar (C63); ff63=fft2(polar63); polar63=log(abs(ff63)); P63 = reshape(polar63,1,15*64); P63= P63'; result = sim(net,p63) A64 = imread ('retangulo 21.jpg','jpg'); B64 = rgb2gray (A64); C64 = edge (B64,'sobel'); polar64= log_polar (C64); ff64=fft2(polar64); polar64=log(abs(ff64)); P64 = reshape(polar64,1,15*64); P64= P64'; result = sim(net,p64) A65 = imread ('retangulo 22.jpg','jpg'); B65 = rgb2gray (A65); C65 = edge (B65,'sobel'); polar65= log_polar (C65); ff65=fft2(polar65); polar65=log(abs(ff65)); P65 = reshape(polar65,1,15*64); P65= P65'; result = sim(net,p65)

43 40 A66 = imread ('quadrado 15.jpg','jpg'); B66 = rgb2gray (A66); C66 = edge (B66,'sobel'); polar66= log_polar (C66); ff66=fft2(polar66); polar66=log(abs(ff66)); P66 = reshape(polar66,1,15*64); P66= P66'; result = sim(net,p66) A67 = imread ('quadrado 16.jpg','jpg'); B67 = rgb2gray (A67); C67 = edge (B67,'sobel'); polar67= log_polar (C67); ff67=fft2(polar67); polar67=log(abs(ff67)); P67 = reshape(polar67,1,15*64); P67= P67'; result = sim(net,p67) A68 = imread ('quadrado 17.jpg','jpg'); B68 = rgb2gray (A68); C68 = edge (B68,'sobel'); polar68= log_polar (C68); ff68=fft2(polar68); polar68=log(abs(ff68)); P68 = reshape(polar68,1,15*64); P68= P68'; result = sim(net,p68) A69 = imread ('quadrado 18.jpg','jpg'); B69 = rgb2gray (A69); C69 = edge (B69,'sobel'); polar69= log_polar (C69); ff69=fft2(polar69); polar69=log(abs(ff69)); P69 = reshape(polar69,1,15*64); P69= P69'; result = sim(net,p69) A70 = imread ('quadrado 19.jpg','jpg'); B70 = rgb2gray (A70); C70 = edge (B70,'sobel'); polar70 = log_polar (C70); ff70=fft2(polar70); polar70=log(abs(ff70)); P70 = reshape(polar70,1,15*64); P70= P70'; result = sim(net,p70)

44 41 A71 = imread ('quadrado 20.jpg','jpg'); B71 = rgb2gray (A71); C71 = edge (B71,'sobel'); polar71 = log_polar (C71); ff71=fft2(polar71); polar71=log(abs(ff71)); P71 = reshape(polar71,1,15*64); P71= P71'; result = sim(net,p71) A72 = imread ('triangulo 10.jpg','jpg'); B72 = rgb2gray (A72); C72 = edge (B72,'sobel'); polar72 = log_polar (C72); ff72=fft2(polar72); polar72=log(abs(ff72)); P72 = reshape(polar72,1,15*64); P72= P72'; result = sim(net,p72) A73 = imread ('triangulo 11.jpg','jpg'); B73 = rgb2gray (A73); C73 = edge (B73,'sobel'); polar73 = log_polar (C73); ff73=fft2(polar73); polar73=log(abs(ff73)); P73 = reshape(polar73,1,15*64); P73= P73'; result = sim(net,p73) A74 = imread ('triangulo 12.jpg','jpg'); B74 = rgb2gray (A74); C74 = edge (B74,'sobel'); polar74 = log_polar (C74); ff74=fft2(polar74); polar74=log(abs(ff74)); P74 = reshape(polar74,1,15*64); P74= P74'; result = sim(net,p74) A75 = imread ('triangulo 13.jpg','jpg'); B75 = rgb2gray (A75); C75 = edge (B75,'sobel'); polar75 = log_polar (C75); ff75=fft2(polar75); polar75=log(abs(ff75)); P75 = reshape(polar75,1,15*64); P75= P75'; result = sim(net,p75) A76 = imread ('triangulo 14.jpg','jpg'); B76 = rgb2gray (A76); C76 = edge (B76,'sobel'); polar76 = log_polar (C76);

45 42 ff76=fft2(polar76); polar76=log(abs(ff76)); P76 = reshape(polar76,1,15*64); P76= P76'; result = sim(net,p76) %todo A77 = imread ('triangulo 15.jpg','jpg'); B77 = rgb2gray (A77); C77 = edge (B77,'sobel'); polar77 = log_polar (C77); ff77=fft2(polar77); polar77=log(abs(ff77)); P77 = reshape(polar77,1,15*64); P77= P77'; result = sim(net,p77) A78 = imread ('triangulo 16.jpg','jpg'); B78 = rgb2gray (A78); C78 = edge (B78,'sobel'); polar78 = log_polar (C78); ff78=fft2(polar78); polar78=log(abs(ff78)); P78 = reshape(polar78,1,15*64); P78= P78'; result = sim(net,p78) A79 = imread ('triangulo 17.jpg','jpg'); B79 = rgb2gray (A79); C79 = edge (B79,'sobel'); polar79 = log_polar (C79); ff79=fft2(polar79); polar79=log(abs(ff79)); P79 = reshape(polar79,1,15*64); P79= P79'; result = sim(net,p79) A80 = imread ('triangulo 18.jpg','jpg'); B80 = rgb2gray (A80); C80 = edge (B80,'sobel'); polar80 = log_polar (C80); ff80=fft2(polar80); polar80=log(abs(ff80)); P80 = reshape(polar80,1,15*64); P80= P80'; result = sim(net,p80) A81 = imread ('triangulo 19.jpg','jpg'); B81 = rgb2gray (A81); C81 = edge (B81,'sobel'); polar81 = log_polar (C81); ff81=fft2(polar81); polar81=log(abs(ff81)); P81 = reshape(polar81,1,15*64); P81= P81';

46 43 result = sim(net,p81) A82 = imread ('triangulo 21.jpg','jpg'); B82 = rgb2gray (A82); C82 = edge (B82,'sobel'); polar82 = log_polar (C82); ff82=fft2(polar82); polar82=log(abs(ff82)); P82 = reshape(polar82,1,15*64); P82= P82'; result = sim(net,p82) A83 = imread ('triangulo 22.jpg','jpg'); B83 = rgb2gray (A83); C83 = edge (B83,'sobel'); polar83 = log_polar (C83); ff83=fft2(polar83); polar83=log(abs(ff83)); P83 = reshape(polar83,1,15*64); P83= P83'; result = sim(net,p83) A84 = imread ('circulo 18.jpg','jpg'); B84 = rgb2gray (A84); C84 = edge (B84,'sobel'); polar84 = log_polar (C84); ff84=fft2(polar84); polar84=log(abs(ff84)); P84 = reshape(polar84,1,15*64); P84= P84'; result = sim(net,p84) A85 = imread ('circulo 19.jpg','jpg'); B85 = rgb2gray (A85); C85 = edge (B85,'sobel'); polar85 = log_polar (C85); ff85=fft2(polar85); polar85=log(abs(ff85)); P85 = reshape(polar85,1,15*64); P85= P85'; result = sim(net,p85) A86 = imread ('circulo 20.jpg','jpg'); B86 = rgb2gray (A86); C86 = edge (B86,'sobel'); polar86 = log_polar (C86); ff86=fft2(polar86); polar86=log(abs(ff86)); P86 = reshape(polar86,1,15*64); P86= P86'; result = sim(net,p86)

47 44 A87 = imread ('circulo 21.jpg','jpg'); B87 = rgb2gray (A87); C87 = edge (B87,'sobel'); polar87 = log_polar (C87); ff87=fft2(polar87); polar87=log(abs(ff87)); P87 = reshape(polar87,1,15*64); P87= P87'; result = sim(net,p87) A88 = imread ('circulo 22.jpg','jpg'); B88 = rgb2gray (A88); C88 = edge (B88,'sobel'); polar88 = log_polar (C88); ff88=fft2(polar88); polar88=log(abs(ff88)); P88 = reshape(polar88,1,15*64); P88= P88'; result = sim(net,p88) cd f: cd tcc dir addpath edit 'comandos matlab tcc.rtf' % tringuglo A5 = imread ('t5.jpg','jpg'); B5 = rgb2gray (A5); C5 = edge(b5,'sobel'); polar5 = log_polar(c5); figure imshow (polar5); F=fft2(polar5,256,256); F2=log(abs(F); F2=log(abs(F)); imshow(f2,[-1 5]); colormap(jet); colorbar figure imshow(a5); imshow(b5); figure imshow(b5); imshow(c5); figure imshow(f2,[-1 5]); colormap(jet); colorbar figure imshow(f,[-1 5]); colormap(jet); colorbar F=fft2(polar5); F2=log(abs(F)); imshow(f2,[-1 5]); colormap(jet); colorbar close all imshow(f2,[-1 5]); colormap(jet); colorbar imshow(f2,[-1 5]); A3 = imread ('quadrado.jpg','jpg'); B3 = rgb2gray(a3); C3 = edge(b3,'sobel'); polar3 = log_polar(c3); figure

48 imshow(polar3); Q=fft2(polar5); Q=fft2(polar3); Q2=log(abs(Q)); figure imshow(q2); A4 = imread ('quadrado2.jpg','jpg'); B4 = rgb2gray(a4); C4 = edge(b4,'sobel'); polar4 = log_polar(c4); figure imshow(polar4); figure imshow(c4); figure imshow(c3); QB=fft2(polar4); QB2=log(abs(QB)); figure imshow(qb2); 45

49 Apêndice B Artigo formato SBC 46

50 Reconhecimento de objetos geométricos em imagens Flávio da Silveira Pepino 1 1 Instituto de Informática e Estatística Universidade Federal de Santa Catarina (UFSC) Caixa Postal Florianópolis SC Brazil flavio@inf.ufsc.br Abstract. This work has built a computer simulation of vision of the Matlab environment, the simulator uses an artificial neural network for classification of geometric shapes (circle, square, triangle or rectangle) in an image. The task of recognition of images was divided into two stages: pre-processing and classification using a neural network. On the stage of pre-processing, the images were processed by an algorithm for detecting edges, using the algorithm of Sobel, which eliminates the background against which the image is, leaving only the outline of the object being recognized. Algorithm was used log-polar have been made to make the system invariant the effects of translation, rotation and scale. The resultant vector was used as inputs to the neural network. In the classification used a neural network was created in Matlab environment. Two samples were used to train the network, and 20 (twenty) for tests for each class. Resumo. Este trabalho construiu uma simulador de visão de computador no ambiente Matlab, o simulador utiliza uma rede neural artificial para classificação de formas geométricas (círculo,quadrado, triângulo ou retângulo) presentes em uma imagem. A tarefa de reconhecimento de imagens foi dividida em duas etapas: pré-processamento e classificação através de uma rede neural. Na etapa de pré-processamento, as imagens foram processadas por um algoritmo de detecção de bordas, utilizando o algoritmo de Sobel, que elimina o fundo contra o qual a imagem se encontra, deixando apenas o contorno do objeto a ser reconhecido. Foi utilizado o algoritmo logpolar foram tornar para tornar o sistema invariante a efeitos de translação, rotação e escala. O vetor resultante foi usado como entradas para a rede neural. Na classificação foi utilizada uma rede neural criada no ambiente Matlab. Duas amostras foram utilizadas para treinar a rede, e 20 (vinte) para testes para cada classe. 1. Introdução Visão computacional é um sistema computadorizado capaz de adquirir, processar e interpretar imagens correspondentes a cenas reais (Filho, 1999, pg.13). Redes neurais artificiais são estruturas de dados inspiradas na estrutura e funcionamento de uma coleção de neurônios. O trabalho das redes neurais artificiais, informalmente também chamadas de redes neurais, é motivado pela forma diferente de como o computador digital funciona. O cérebro é um sistema de processamento de informação altamente complexo, não-linear e paralelo (Haykin, 2001, p. 27). Um neurônio é uma

51 célula nervosa cuja função é coletar, processar e disseminar sinais elétricos. De uma forma simplificada, um neurônio transmite um sinal para outro neurônio da rede quando uma combinação linear de suas entradas ultrapassa um limiar. A visão humana é uma tarefa de processamento de informação cuja função é fornecer uma representação do ambiente para que possamos interagir com ele. O cérebro realiza a todo o momento tarefas de reconhecimento perceptivo (rostos, cenas) em aproximadamente ms (Haykin, 2001, p. 27), enquanto problemas de muito menor complexidade acabam por necessitar um esforço computacional elevado em um computador digital, muito além de milisegundos. De uma forma geral, uma rede neural é uma máquina que é projetada para modelar a maneira como nosso cérebro realiza uma tarefa em particular (função de interesse), e ela é implementada e executada em um computador digital. O interesse deste trabalho é em uma classe de redes neurais que realizam a computação útil através de um processo de aprendizagem. O procedimento utilizado para realizar o processo de aprendizagem é chamado de algoritmo de aprendizagem. Redes neurais têm sido utilizadas largamente em aplicações de reconhecimento de imagens devido ao seu poder de aprendizado. 2. Fundamentação Teórica Um sinal analógico de vídeo, obtido no caso por uma câmera, deve ser discretizado em relação ao seu espaço e sua amplitude para se tornar apto ao processamento digital.o modelo para lidar com imagens assume uma matriz MxN de intensidade de luz no plano de uma imagem que podemos chamar de I(x,y). O espaço está relacionado à resolução da imagem.e a amplitude da imagem está relacionada com a quantidade de tons de cinzas.cada posição na matriz, ou seja, cada pixel possui um valor relacionado ao tom de cinza, que pode ser um valor inteiro na faixa 0 a 2n-1. Uma rede neural é um processador maciçamente paralelamente distribuído constituído de unidades de processamento simples, que têm a propensão natural para armazenar conhecimento experimental e torná-lo disponível para uso, os aspectos relevantes das RNAs relevantes para este trabalho são o processo de aprendizagem e forças de conexão entre os neurônios (chamados de pesos sinápticos), que são utilizados para armazenar o conhecimento adquirido. A alteração dos pesos sinápticos é a maneira usual para projetar redes neurais. O poder das redes neurais advém de sua estrutura paralela e sua capacidade de generalização. Generalização é a capacidade da RNA produzir saídas adequadas para entradas que não foram dadas durante o treinamento (aprendizagem). Estas duas habilidades de processamento da informação dão às RNAs possibilidade de resolver problemas complexos que são difíceis por outras abordagens. Entre as propriedades das redes neurais artificiais apresentadas por Haykin (2001) as seguintes são interessantes para o trabalho:mapeamento de entrada-saída, mais conhecido como aprendizado supervisionado, e a adaptabilidade, ou seja, a capacidade da RNA de alterar seu valores de pesos sinápticos 3. Metodologia Para obter a visão um computador precisa transformar a imagem para que ela se torne apta para seu reconhecimento. É necessário também extrair características que possam ser invariantes do objeto independendo da disposição do objeto na imagem. Foi