RECONHECIMENTO DE OBJETOS GEOMÉTRICOS EM IMAGENS

(1)

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

(2)

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)

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)

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

(5)

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.

(6)

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.

(7)

1 Introdução...8 1.1 Especificação do problema...9 1.2 Objetivos...9 1.3 Justificativa...9 1.4 Estrutura do trabalho...10 2. Fundamentação Teórica...11 2.1 Imagem Digital...11

2.2 Rede Neural Artificial...12

2.2.1 Unidades em redes neurais artificiais...14

2.2.2 Estrutura da rede...14 2.3 Transformada Log-Polar...15 3 .Metodologia...18 3.1 Aquisição de imagens...18 3.2 Pré-processamento de imagens...18 3.3 Classificação...21 4. Resultado...24 5. Conclusão...25 Referências...26 Apêndices...27

Apêndice A – Código Matlab Simulador e testes...27

(8)

Figura 1 Plano de Imagem... 11

Figura 2 Unidade em redes neurais ... …...14

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

(9)

1: Vetor de saída da RNA...22 2: 8 Vetores de saída gerados para cada exemplo no treinamento...23 3 Acertos nos testes antes da Transformada de Fourier...24

(10)

RNA

(11)

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 100-200 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)

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.

1.2.2 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)

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)

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 2n-1 .

(15)

2.2 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)

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.

2.2.1 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)

Figura 2: Unidade rede neural artificial

2.2.2 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).

(18)

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)

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}

(1)     θ = θ = ρ ρ sen e v cos e u

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.

(21)

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.

3. 2 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

(22)

Log-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 5. Detecção de arestas usando o algoritmo de Sobel.

(23)

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)

3.3 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 0.001.

(25)

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 [1 -1 -1 -1]

Quadrado [-1 1 -1 -1]

Triângulo [-1 -1 1 -1]

Retângulo [-1 -1 -1 1]

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)

Classe 2 Círculos 2 Quadrados 2 Triângulos 2 Retângulos Círculo 0.9247 0.8903 -0.9310 -0.9092 -0.9969 -0.9946 -0.9203 -0.8711 Quadrado -0.8941 -0.8676 0.8391 0.8412 -0.9867 -0.9956 -0.8641 -0.8024 Triângulo -0.9828 -0.9567 -0.9449 -0.9649 0.9286 0.9390 -0.8812 -0.8535 Retângulo -0.9310 -0.9633 -0.9130 -0.9198 -0.9670 -0.8853 0.8642 0.8642

Tabela 2: 8 Vetores de saída gerados para cada exemplo no treinamento

A rede convergiu para em 44 épocas como pode ser vista na figura.

(27)

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)

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 65.536 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)

Referências bibliográficas

HAYKIN, Simon. Redes Neurais: Principios e prática. 2ª Edição. Porto Alegre: Bookman, 2001.

RUSSEL, Stuart; NORVIG, Peter. Inteligência Artificial: Tradução da segunda edição. Rio de Janeiro: Elsevier, 2004.

NETO, Hugo Vieira; FILHO, Ogê Marques. Processamento Digital de Imagens. Rio de Janeiro: Brasport, 1999.

(30)

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)

% 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=[1 -1 -1 -1; 1 -1 -1 -1; -1 1 -1 -1; -1 1 -1 -1; -1 -1 1 -1; -1 -1 1 -1; -1 -1 -1 1; -1 -1 -1 1]; 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 1.39395/0.01, Gradient 1.21022/1e-006 TRAINGDX, Epoch 25/1000, MSE 0.825993/0.01, Gradient 1.6698/1e-006 TRAINGDX, Epoch 50/1000, MSE 0.213121/0.01, Gradient 0.651057/1e-006 TRAINGDX, Epoch 75/1000, MSE 0.0121527/0.01, Gradient 0.0474644/1e-006 TRAINGDX, Epoch 79/1000, MSE 0.009547/0.01, Gradient 0.0371515/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)

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) %OK

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) %OK

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

(33)

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) %OK

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) %OK

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)

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) %OK

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) %OK

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)

polar23=log(abs(ff23));

P23 = reshape(polar23,1,15*64); P23= P23';

result = sim(net,P23)

%OK

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) %OK

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)

%OK

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)

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) %OK

A34 = imread ('circulo 11.jpg','jpg'); B34 = rgb2gray (A34);

(37)

polar34 = log_polar (C34); ff34=fft2(polar34); polar34=log(abs(ff34)); P34 = reshape(polar34,1,15*64); P34= P34'; result = sim(net,P34) %OK

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)

P39= P39';

%OK

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) %

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)

%OK

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) %OK

A50 = imread ('quadrado 14.jpg','jpg'); B50 = rgb2gray (A50);

(40)

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) %OK

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

A55 = imread ('retangulo 14.jpg','jpg'); B55 = rgb2gray (A55);

C55 = edge (B55,'sobel'); polar55= log_polar (C55); ff55=fft2(polar55);

(41)

P55 = reshape(polar55,1,15*64); P55= 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

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)

P60= P60';

%OK

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) %OK

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

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)

%OK

(44)

A76 = imread ('triangulo 14.jpg','jpg'); B76 = rgb2gray (A76);

C76 = edge (B76,'sobel'); polar76 = log_polar (C76);

(45)

ff76=fft2(polar76); polar76=log(abs(ff76)); P76 = reshape(polar76,1,15*64); P76= P76'; result = sim(net,P76) %todo

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)

%OK

(47)

%OK

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);

(49)

(50)

Flávio da Silveira Pepino1

1_{Instituto de Informática e Estatística– Universidade Federal de Santa Catarina (UFSC)}

Caixa Postal 476 – 88040-900 – 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 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 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)

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 100-200 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

(52)

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.

3.2 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-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.

3.3 Classificaçã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 0.001. 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

Circulo [1 -1 -1 -1]

Quadrado [-1 1 -1 -1]

Triângulo [-1 -1 1 -1]

(53)

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

Classe 2 Círculos 2 Quadrados 2 Triângulos 2 Retângulos

Círculo 0.9247 0.8903 -0.9310 -0.9092 -0.9969 -0.9946 -0.9203 -0.8711 Quadrado -0.8941 -0.8676 0.8391 0.8412 -0.9867 -0.9956 -0.8641 -0.8024 Triângulo -0.9828 -0.9567 -0.9449 -0.9649 0.9286 0.9390 -0.8812 -0.8535 Retângulo -0.9310 -0.9633 -0.9130 -0.9198 -0.9670 -0.8853 0.8642 0.8642

4. Resultado

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.

(54)

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 65.536 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.

Referências

Haykin, Simon (2001) “Redes Neurais: Principios e prática.”, 2ª Edição. Porto Alegre: Bookman, 2001.

Russel, Stuart; Norvig, Peter.(2004) “Inteligência Artificial: Tradução da segunda edição”, Rio de Janeiro: Elsevier,

Neto, Hugo Vieira; Filho, Ogê Marques.(1999) “Processamento Digital de Imagens”, Rio de Janeiro: Brasport, 1999.

Bow, Sing-Tze. (2002) ”Pattern Recognition and Image Preprocessing.”, DeKalb: Dekker,