Embed Size (px)
Citation preview
UNIVERSIDADE FEDERAL DE SANTA CATARINACENTRO TECNOLÓGICO
DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICACURSO DE CIÊNCIAS DA COMPUTAÇÃO
RECONHECIMENTO DE OBJETOS GEOMÉTRICOS EM
IMAGENS
Flavio da Silveira Pepino
Florianópolis -SC
2008/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
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 =).
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
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
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
Sumário
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
Anexo 1 – Artigo Formato SBC..........................................................................46
Lista de figuras
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
Figura 11 Treinamento da rede.........................................................................23
Lista de Tabelas
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
Lista de acrônimos e abreviações
RNA
Rede Neural Artificial
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 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.
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.
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
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.
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 2n-1 .
12
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
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.
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.
14
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).
Figura 3: Estrutura de RNA com uma camada oculta.
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.
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
(1)
θ=θ=
ρ
ρ
senevcoseu
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 fLP fLP f
( )( , )( )( , )( )( )
ρ θρ θ
=− ∞
.
17
Observa-se que a transformação LP-normalizada, como a TF, é invariante sob translação.
3. Metodologia
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.
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-
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 5. Detecção de arestas usando o algoritmo de Sobel.
Figura 4. Exemplo de cada classe de uma imagem original.
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
21
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.
22
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
Figura 10: Arquitetura de RNA proposta
23
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.
Figura 11: Treinamento da rede
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.
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 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.
26
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.
BOW, Sing-Tze. Pattern Recognition and Image Preprocessing. DeKalb: Dekker, 2002.
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)); %quadradoA3 = 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)); % tringugloA5 = 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));
28
% retanguloA7 = 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 neuralP1=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-006TRAINGDX, Epoch 25/1000, MSE 0.825993/0.01, Gradient 1.6698/1e-006TRAINGDX, Epoch 50/1000, MSE 0.213121/0.01, Gradient 0.651057/1e-006TRAINGDX, Epoch 75/1000, MSE 0.0121527/0.01, Gradient 0.0474644/1e-006TRAINGDX, Epoch 79/1000, MSE 0.009547/0.01, Gradient 0.0371515/1e-006TRAINGDX, Performance goal met. % OKA9 = 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';
29
result=sim(net,P9) %teste quadrado OKA10 = 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 okA11 = 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) %OKA12 = 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) % OKA14 = imread ('triangulo 3.jpg');
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) %OKA15 = 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) %OKA16 = 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) % OKA17 = 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);
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) % OKA20 = 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) % OKA20 = 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) %OKA21 = 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) %OKA22 = 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) % OKA23 = imread ('triangulo 5.jpg','jpg');B23 = rgb2gray (A23);C23 = edge (B23,'sobel');polar23 = log_polar (C23);ff23=fft2(polar23);
32
polar23=log(abs(ff23));P23 = reshape(polar23,1,15*64);P23= P23';result = sim(net,P23) %OKA24 = 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) %OKA25 = 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) %OKA26 = 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) %OKA27 = 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) %OKA28 = 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';
33
result = sim(net,P28) %OKA29 = 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) % OKA30 = 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) %OKA34 = imread ('circulo 11.jpg','jpg');B34 = rgb2gray (A34);C34 = edge (B34,'sobel');
34
polar34 = log_polar (C34);ff34=fft2(polar34);polar34=log(abs(ff34));P34 = reshape(polar34,1,15*64);P34= P34';result = sim(net,P34) %OKA35 = 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) %OKA36 = 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) %OKA37 = 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) %OKA38 = 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) %OKA39 = 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);
35
P39= P39';result = sim(net,P39) %OKA40 = 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) %OKA42 = 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) %OKA43 = 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) %OKA44 = 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)
36
%OKA45 = 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) %OKA46 = 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) %OKA47 = 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) %OKA48 = 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) %OKA49 = 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) %OKA50 = imread ('quadrado 14.jpg','jpg');B50 = rgb2gray (A50);
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) %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) % OKA53 = 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)% okA54 = 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));
38
P55 = reshape(polar55,1,15*64);P55= P55';result = sim(net,P55) % okA56 = 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)%okA57 = 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) %okA58 = 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) % okA59 = 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) % okA60 = 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);
39
P60= P60';result = sim(net,P60) %OKA61 = 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) % OKA63 = 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) %OKA64 = 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) %OKA65 = 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)
40
%OKA66 = 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) %OKA67 = 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) %OKA68 = 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) %OKA69 = 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) %OKA70 = 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) %OK
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) %OKA72 = 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) %OKA73 = 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) %OKA74 = 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) %OKA75 = 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) %OKA76 = imread ('triangulo 14.jpg','jpg');B76 = rgb2gray (A76);C76 = edge (B76,'sobel');polar76 = log_polar (C76);
42
ff76=fft2(polar76);polar76=log(abs(ff76));P76 = reshape(polar76,1,15*64);P76= P76';result = sim(net,P76) %todoA77 = 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) %OKA78 = 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) %OKA79 = 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) %OKA80 = 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) %OKA81 = 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';
43
result = sim(net,P81) %OKA82 = 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) %OKA83 = 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) %OKA84 = 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) %OKA85 = 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) %OKA86 = 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)
44
%OKA87 = 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) %OKA88 = 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 tccdiraddpathedit 'comandos matlab tcc.rtf'% tringugloA5 = imread ('t5.jpg','jpg');B5 = rgb2gray (A5);C5 = edge(B5,'sobel');polar5 = log_polar(C5);figureimshow (polar5);F=fft2(polar5,256,256);F2=log(abs(F);F2=log(abs(F));imshow(F2,[-1 5]); colormap(jet); colorbarfigureimshow(A5);imshow(B5);figureimshow(B5);imshow(C5);figureimshow(F2,[-1 5]); colormap(jet); colorbarfigureimshow(F,[-1 5]); colormap(jet); colorbarF=fft2(polar5);F2=log(abs(F));imshow(F2,[-1 5]); colormap(jet); colorbarclose allimshow(F2,[-1 5]); colormap(jet); colorbarimshow(F2,[-1 5]);A3 = imread ('quadrado.jpg','jpg');B3 = rgb2gray(A3);C3 = edge(B3,'sobel');polar3 = log_polar(C3);figure
45
imshow(polar3);Q=fft2(polar5);Q=fft2(polar3);Q2=log(abs(Q));figureimshow(Q2);A4 = imread ('quadrado2.jpg','jpg');B4 = rgb2gray(A4);C4 = edge(B4,'sobel');polar4 = log_polar(C4);figureimshow(polar4);figureimshow(C4);figureimshow(C3);QB=fft2(polar4);QB2=log(abs(QB));figureimshow(QB2);
46
Apêndice B – Artigo formato SBC
Reconhecimento de objetos geométricos em imagens
Flávio da Silveira Pepino1
1Instituto de Informática e Estatística– Universidade Federal de Santa Catarina (UFSC)Caixa Postal 476 – 88040-900 – Florianópolis – SC – Brazil
[email protected]. 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çãoVisã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.
2. Fundamentação TeóricaUm 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. MetodologiaPara 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 imagensO 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 imagemEleitos 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çãoDadas 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]
Retângulo [-1 -1 -1 1]
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
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. ResultadoForam 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.
5. ConclusãoNeste 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,
