faculdade farias brito - ffb.edu.br · faculdade farias brito ciÊncia da computaÇÃo antonio...
TRANSCRIPT
FACULDADE FARIAS BRITO CIÊNCIA DA COMPUTAÇÃO
ANTONIO VINICIUS G. DE LIMA
Processamento de imagens para identificação de placas de automóveis
Fortaleza, 2009
ANTONIO VINICIUS G. DE LIMA
Processamento de imagens para identificação de placas de automóveis
Monografia apresentada para obtenção dos créditos da disciplina Trabalho de Conclusão do Curso da Faculdade Farias Brito, como parte das exigências para graduação no Curso de Ciência da Computação.
Orientadora: Wietske I. Meyering, Dra.
Fortaleza, 2009
PROCESSAMENTO DE IMAGENS PARA IDENTIFICAÇÃO DE PLACAS DE AUTOMÓVEIS
Antonio Vinicius G. de Lima
NOTA: FINAL (0 – 10): __
Data: / /
BANCA EXAMINADORA:
Dra. Wietske Ineke Meyering
Orientadora
MSc. Roberto de Almeida Façanha
Examinador
MSc. José Belo Aragão Júnior
Examinador
“staying awake to chase the dream”
Muse
Dedico este trabalho a minha família, em especial a minha mãe, pois representaram a motivação central para a
conclusão do mesmo.
AGRADECIMENTOS
Á Orientadora Dra Wietske Meyering, pela gerência, criatividade, ajuda,
disponibilidade e certeza da realização deste trabalho o que permitiu que o projeto fosse
concluído com qualidade.
Á Juliana Ponte por incentivar, criticar, relembrar, entreter, revisar e me alertar, tarefas
que exigiram esforço e jogo de cintura. Agradecê-la principalmente por não desistir de
carregar este fardo.
Á Godva Grace por acreditar, por entender e principalmente por me lembrar que existia
um ‘após’, pelo incentivo em todos os momentos e pelas palavras de conforto sempre que
preciso.
Aos amigos pessoais e profissionais por se colocarem a disposição e se mostrarem
prontos a ajudar sempre. Em especial a Elidiane, Tatiana, Rosanne e Rosiane.
Aos professores e colegas de curso que ajudaram de maneira direta ou indireta para a
minha formação.
E a todos que contribuíram de alguma forma para a realização deste trabalho.
RESUMO
O estado da arte da área de Processamento de Imagens é composto por estudos para soluções especializadas, em especial quando se trata do reconhecimento de caracteres. Esta vertente de estudo, especificamente, é composta por soluções que são destinadas a um grupo limitado de imagens e cuja migração a outros domínios de aplicação necessita de um esforço enorme de reescrita da aplicação. A área como um todo apresenta o agravante de não possuir um catalisador de novos pesquisadores, o que limita o escopo de estudos realizados. O trabalho busca desenvolver a partir da construção de uma base teórica sólida e com facilidade de entendimento a ingressantes na área, desenvolver os módulos de processamento básico e intermediário de um protótipo de reconhecimento de caracteres em placas de automóveis. Para realização deste procedimento foi implementada uma forma de segmentação da imagem que separe o código de identificação da placa do resto da imagem, através da identificação da borda. Para além do protótipo como resultado o projeto prevê que o documento final possa ser utilizado como um modelo para desenvolvimento de outros protótipos na área.
Palavras chave: imagens, desenvolvimento, protótipo, caracteres, segmentação.
SUMÁRIO
INTRODUÇÃO ................................................................................................................................................... 14
1. REFERENCIAL TEÓRICO ..................................................................................................................... 18
1.1 Definição ............................................................................................................................................ 18
1.2 A Imagem Digital ................................................................................................................................ 19
1.3 Processamento de Imagens Digitais ................................................................................................... 21
1.3.1 Segmentação ....................................................................................................................................... 23
1.3.1.1 Segmentação por Descontinuidade ............................................................................................ 24
1.3.1.2 Segmentação por Similaridade ................................................................................................... 27
1.3.2 Morfologia Matemática ....................................................................................................................... 29
1.4 Reconhecimento de Padrões .............................................................................................................. 33
1.4.1 Métodos de Abordagem ...................................................................................................................... 34
1.5 Linguagem Matlab .............................................................................................................................. 35
2. FERRAMENTAS DE DESENVOLVIMENTO ....................................................................................... 38
2.1 MathWorks™ Matlab ......................................................................................................................... 38
2.2 GNU Octave........................................................................................................................................ 39
2.3 Base de Dados .................................................................................................................................... 41
2.4 Desenvolvimento de Interface com o Usuário .................................................................................... 41
3. DESENVOLVIMENTO DO PROTÓTIPO ............................................................................................. 43
3.1 Módulos ............................................................................................................................................. 43
3.2 Integração dos Módulos ..................................................................................................................... 45
3.3 Implementação da Base de Dados ...................................................................................................... 46
4. TESTES ....................................................................................................................................................... 48
4.1 Massa de Teste ................................................................................................................................... 48
4.2 Realização dos Testes ......................................................................................................................... 50
4.3 Critérios de Aceitação dos Scripts ....................................................................................................... 51
4.4 Resultados Obtidos ............................................................................................................................ 52
5. DOCUMENTAÇÃO ................................................................................................................................... 64
5.1 Desenvolvimento do Protótipo .......................................................................................................... 64
5.2 Realização dos Testes ......................................................................................................................... 65
6. CONCLUSÕES ........................................................................................................................................... 67
7. TRABALHOS FUTUROS ......................................................................................................................... 71
REFERÊNCIAS BIBLIOGRÁFICAS............................................................................................................... 73
MATERIAL DE ESTUDO ................................................................................................................................. 76
APÊNDICE A – MODELOS DE FORMATO DOS ARQUIVOS FONTE.................................................... 78
APÊNDICE B – MODELOS DE PLANILHA DE CONTROLE DE RESULTADO DOS TESTES .......... 79
APÊNDICE C – CÓDIGOS DA IMPLEMENTAÇÃO ................................................................................... 80
APÊNDICE D – MASSA DE TESTES .............................................................................................................. 93
ANEXO I - CONSTRUÇÃO DA INTERFACE ............................................................................................. 105
ANEXO II - CONEXÃO COM O BANCO ..................................................................................................... 109
LISTA DE FIGURAS
Figura 1 - Imagens digitais com tamanho igual e resolução diferente (SCURI, 2002) ......................... 20
Figura 2 - Representação da vizinhança de um pixel ............................................................................ 21
Figura 3 - Níveis de Processamento (GONZALEZ; WOODS, 2000, p. 408) ...................................... 22
Figura 4 - Máscaras:(a) detecção de pontos e de linhas (b) Horizontal (c) Vertical (d) +45º (e) -45º .. 25
Figura 5 - Exemplos de Histograma (LEITE, 2004) ............................................................................. 26
Figura 6 - (a) Imagem tratada com um filtro ,(b) operador de Roberts ,(c)operador de Sobel e exemplos de máscaras utilizadas em (d) Roberts e em (e) Sobel. (FELGUEIRAS, 2007, alterada) .... 27
Figura 7 - Máscara utilizada no operador Laplaciano ........................................................................... 27
Figura 8 - Exemplo da aplicação da limiarização (a) Imagem original em tons de cinza (b) Imagem binarizada por limiarização (LEITE, 2004) .......................................................................................... 28
Figura 9 - Exemplos de Elementos Estruturantes de formas comuns: (a) Cruz e o (b) Quadrado. (NEVES, 2003) ..................................................................................................................................... 30
Figura 10 - Exemplos de (ii) erosão e (iii) dilatação sobre a imagem apresentada em (i). (GONZALEZ; WOODS, 2000) ..................................................................................................................................... 31
Figura 11 - Exemplos de (a) Abertura e (b) Fechamento. (GONZALEZ; WOODS, 2000) ................. 32
Figura 12 - Tela inicial Matlab R2007b. ............................................................................................... 39
Figura 13 - Tela inicial Octave 3.2.3. .................................................................................................... 40
Figura 14 – Exemplos de imagens da massa de testes básica. Caracteres (i, ii e iii) e linhas(iv, v, vi, vii, viii) .................................................................................................................................................. 49
Figura 15 – Exemplos de imagens de calibração. Criada (i, ii e iii) e simulação(iv, v, vi,) .................. 49
Figura 16 – Exemplos de imagens utilizadas no teste provenientes da base de imagens do CBPF/MCT ............................................................................................................................................................... 50
Figura 17 – Exemplo da planilha de rastreabilidade dos identificadores dos códigos. ......................... 51
Figura 18 - Adição das imagens (i) e (ii), resultando em (iii). Função executada no Matlab. .............. 53
Figura 19 - Subtração das imagens (i) e (ii), resultando em (iii). Função executada no Matlab. .......... 54
Figura 20 – Histograma (ii) da imagem(i) com a função executada no Matlab. ................................... 55
Figura 21 - Histograma (ii) da imagem binária (i) com a função executada no Octave. ...................... 55
Figura 22 – Imagem original proveniente da base de imagens. ............................................................ 55
Figura 23 - Histograma da imagem 22 sem equalização. ...................................................................... 56
Figura 24 – Imagem equalizada proveniente da execução da função no Matlab na imagem exibida na figura 22. ............................................................................................................................................... 56
Figura 25 – Histograma equalizado da imagem 23 – execução no Matlab ........................................... 56
Figura 26– Resultado (ii) da aplicação da função de abertura em uma imagem binária (i) no Octave. 57
Figura 27 – Resultado (ii) da aplicação da função de abertura em uma imagem em tons de cinza (i) realizada no Matlab. .............................................................................................................................. 57
Figura 28 – Aplicação da função de fechamento na imagem (i) resultando na imagem (ii), realizada no Matlab. .................................................................................................................................................. 58
Figura 29 – Aplicação da função de fechamento na imagem (i) resultando na imagem (ii), operação realizada no Octave. .............................................................................................................................. 58
Figura 30 - Resultado (ii) da aplicação da função de esqueletonização na imagem (i) no Matlab. ...... 59
Figura 31 – Resultado da aplicação de detecção de linhas horizontais (ii) e verticais (iii) na imagem (i) no Octave. ............................................................................................................................................. 59
Figura 32 – Resultado da aplicação de detecção de linhas 45º negativo (ii) e positivos (iii) na imagem (i) no Octave. ......................................................................................................................................... 60
Figura 33 – Resultado da aplicação de detecção de linhas (ii) na imagem (i) no Matlab. .................... 60
Figura 34 – Resultado (ii) da aplicação do script de detecção de bordas na imagem (i). Executada no Matlab. .................................................................................................................................................. 61
Figura 35 – Resultado (ii) da aplicação da função de segmentação na imagem (i). Executada no Matlab. .................................................................................................................................................. 61
Figura 36 – Fluxograma para imagens da base de dados CBPF/MCT. ................................................. 62
Figura 37 – Fluxograma para imagens genéricas. ................................................................................. 63
LISTA DE TABELAS
Tabela 1: Sites com informações matlab .............................................................................................................. 39
Tabela 2: Sites com informações octave .............................................................................................................. 40
Tabela 3: Descrição das colunas da tabela “ext_dados” ....................................................................................... 47
Tabela 4: Resultado após os testes dos scripts ..................................................................................................... 52
14
INTRODUÇÃO
A utilização de símbolos para aquisição, guarda e transposição de conhecimento é
um costume antigo das civilizações humanas. Tais símbolos são abundantes nos dias atuais,
seja na forma de escrita cuneiforme, história oral, esculturas, arquitetura, imagens, dentre
outros. O homem desenvolveu diversas vias pelas quais o conhecimento poderia ser
perpetuado. O processo de construção de imagens remonta a 40.000 a.C. e permanece em
constante evolução até os dias atuais (BONFIGLIOLI, 2008).
Apesar da utilização de imagens estar primordialmente associada às artes, um de
seus recursos mais valiosos é o armazenamento de informações. Fotos de época, desenhos,
imagens térmicas, imagens aeroespaciais guardam informações essenciais para diversos
ramos de conhecimento.
O processamento de imagens visa à melhoria da imagem e a extração de
informações (GONZALEZ; WOODS, 2000). A melhoria da imagem tem como objetivo
enaltecer características específicas, visando uma interpretação mais perfeita do conteúdo.
Uma competente extração de informações da imagem só é possível se essa tiver sido
submetida a um processamento prévio, visando a ampliação de características específicas.
Esse processamento engloba as atividades de filtragem e/ou segmentação da imagem. A
extração de informações de imagens digitais surgiu a partir da necessidade do aumento da
confiabilidade de tal ação, visto que a realização da ação por indivíduos humanos aumenta a
probabilidade de erro (TAGLIAFERRO, 2007).
15
A subárea do Processamento de Imagens que se dedica ao estudo dos métodos
para extração confiável de informações é chamada Reconhecimento de Padrões. A intenção
dos pesquisadores dessa área é desenvolver sistemas computacionais com capacidades de
reconhecimento semelhantes às humanas. Diante desse desafio, a área de Reconhecimento de
Padrões busca desenvolver métodos e técnicas especializados que utilizam ou auxiliam
diversas outras áreas de conhecimento.
Inserindo-nos nesse contexto e observando que o reconhecimento automático de
caracteres em imagens ainda é um objetivo e não uma realidade, este trabalho busca agregar
conhecimento nesse ramo da área, buscando o desenvolvimento de um novo método para
preparar imagens que otimize o processo de reconhecimento de caracteres em placas de
automóveis flagrados por barreiras. Para tanto, serão utilizados, como recursos, a morfologia
matemática, em especial a técnica de esqueletonização, haja vista que tais técnicas não são
largamente utilizadas no método de reconhecimento de caracteres. A pouca utilização dessas
técnicas é decorrente de uma inexistência de estudos que validem a sua utilização.
O tópico de reconhecimento de caracteres ainda não realizou avanços
consideráveis. As implementações realizadas atualmente são especializadas em
reconhecimento de letras e números que não contenham uma marca tipográfica (negrito,
itálico, etc.), também há alguns conflitos ao serem analisados caracteres com acentuação.
Adicionalmente, caso o meio que contenha a informação não esteja em condições ideais, a
probabilidade de acerto do processo de reconhecimento cai consideravelmente (CONCI;
AZEVEDO; LETA, 2008).
Diante desse estado da arte do reconhecimento de caracteres, buscou-se a pesquisa
nessa área visando um conhecimento mais profundo, considerando a utilização de um método
de reconhecimento pouco utilizado, esqueletonização das formas. O domínio de aplicação
escolhido foi o reconhecimento da informação de placas de automóveis, números e letras, a
partir de imagens geradas por barreiras eletrônicas.
As barreiras eletrônicas têm por objetivo coibir infrações de trânsito em vias, em
geral urbanas. Seus principais focos de atuação são: monitoramento de tráfego em semáforos
e controle do limite de velocidade. A taxa de acidentes de trânsito cresce de modo alarmante
ano após ano e foi comprovado, com estudos e análise de estatísticas de trânsito, que a
16
implantação de dispositivos, humanos ou eletrônicos de fiscalização reprimem as infrações no
trânsito e auxiliam no cumprimento da lei (PREFEITURA DE FORTALEZA, 2007).
Após a detecção das infrações pela barreira eletrônica o processo padrão é:
recolhimento das informações do dispositivo para o centro de processamento de dados do
órgão responsável onde deverá ser analisado por funcionários para obtenção da informação.
Após esse processo, a multa é gerada oficialmente e encaminhada para o infrator. Esse
processo resulta em um tempo de espera, entre a infração e o recebimento da multa, muito
extenso. De acordo com o Código de Trânsito Brasileiro o infrator tem 30 dias para receber o
auto de infração. Em caso de recebimento posterior ao período estipulado pelo Código
Nacional de Trânsito (CNT), a infração perde a validade, não podendo ser cobrada a multa
(BRASIL, 1997).
Como o domínio de aplicação descrito não contém informações com marcas
tipográficas, foi considerado como campo fértil e promissor para uma pesquisa inicial no
campo de reconhecimento de caracteres. Adicionalmente procura-se agregar um valor social,
auxiliando numa estrutura mais eficiente de aplicação da lei de trânsito e com uma esperada
diminuição das taxas de acidentes com vítimas nas vias de trânsito.
O projeto objetiva construir os módulos de processamento básico e intermediário
que possam ser utilizados como base para um protóripo que realize reconhecimento
automático de placas de automóveis utilizando, como dados de entradas, imagens
provenientes de barreiras eletrônicas, fixas ou móveis. O módulo de processamento
intermediário utilizará prioritariamente a esqueletonização e a segmentação para que a
imagem final possua a qualidade necessária para reconhecimento
O trabalho propõe-se ainda como um incentivador para uma área pouco
fomentada no que se refere ao desenvolvimento de pesquisas, tanto em nível local como
nacional. Em caráter social o projeto destina-se a auxiliar a aplicação da lei nacional de
trânsito, ao passo que propõe estratégias que possam agilizar a detecção da numeração e
conseqüente identificação do autor de infrações em vias públicas que tenham vigilância
eletrônica a partir de barreiras eletrônicas. Observando que o volume de infrações é crescente,
e o aparato humano insuficiente para a correta identificação dos infratores em tempo hábil
para aplicação do Código Nacional de Trânsito. Academicamente, o projeto servirá como
17
modelo para o desenvolvimento de outras aplicações na área de Processamento de Imagens.
O trabalho está dividido em sete capítulos que englobam desde o referencial
teórico até a documentação gerada na construção do protótipo. O primeiro capítulo é
composto pelo arcabouço teórico que norteou o desenvolvimento do projeto e é formado por
tópicos que versam sobre os pontos críticos para o desenvolvimento da aplicação.
O segundo capítulo apresenta as ferramentas utilizadas no processo de
desenvolvimento onde são apresentadas as características principais das ferramentas. No
terceiro capítulo é relatado os componentes dos módulos do protótipo e as implementações
realizadas na base de dados, ou seja, o processo de desenvolvimento em si. No capítulo
subsequente são relatados os testes realizados e os resultados obtidos. O capítulo cinco
explana sobre a documentação utilizada ou criada ao final do processo de desenvolvimento e
de testes. Por fim o capítulo seis exibe as conclusões finais do projeto e o capítulo sete
abrange trabalhos futuros.
18
1. REFERENCIAL TEÓRICO
Este capítulo aborda a pesquisa bibliográfica que constitui o arcabouço teórico do
projeto. Para desenvolvimento do mesmo foram realizadas consultas às obras de autores cuja
contribuição na literatura seja relevante.
O capítulo está dividido sequencialmente numa introdução à área de pesquisa,
definição de imagem digital que é o objeto principal do trabalho de pesquisa, uma explanação
sobre o processamento de imagens, destacando os componentes de segmentação de imagens e
morfologia matemática que compõem essa disciplina, no tópico seguinte é abordada a área de
reconhecimento de padrões e seus principais métodos de abordagem, por fim é feita uma
rápida consideração sobre a linguagem Matlab.
1.1 Definição
A automatização de tarefas por máquinas é um processo desenvolvido pelo
homem visando melhorar a obtenção dos resultados anteriormente obtidos pelo trabalho
braçal. O processo iniciado na Revolução Industrial no Século XVIII desencadeou, motivada
pelo interesse do comércio, uma inédita substituição do método de produção (DIVALTE,
2000). Desde então o homem habituou-se a delegar rotinas que, de algum modo,
representassem um risco ao seu executor ou que, a partir da inserção do maquinário, obtivesse
um ganho de resultados com a automação. O homem passa então a executar novos papéis
como descreve Singer: “A função do Homem não é mais produzir, mas alimentar, vigiar,
manter e reparar a máquina” (SINGER apud DIVALTE, 2000, p. 200). Desde então o
maquinário, industrial e residencial, evolui.
19
Nesse contexto surgem os computadores. Máquinas com objetivo de realizar
cálculos de forma mais eficiente e rápida que os humanos. Como qualquer maquinário os
computadores evoluíram e tornaram-se ferramentas indispensáveis na sociedade. A evolução
computacional buscou a construção de máquinas que simulassem as ações humanas. Uma das
disciplinas que têm se dedicado a esse objetivo é o reconhecimento de padrões (GONZALEZ;
WOODS, 2000).
Reconhecimento de padrões lida com diversas áreas, tais como: Processamento de
Imagens, Inteligência Artificial, Computação Gráfica e ramificações das mesmas. De acordo
com os métodos e técnicas utilizados, a disciplina tem foco e escopo distintos. Este projeto
trata da segmentação de imagens com o intuito de um posterior trabalho na área de
reconhecimento de padrões.
1.2 A Imagem Digital
Imagem digital pode ser definida como uma função bidimensional [1] para
imagens 2-D ou tridimensional [2] para imagens 3-D.
função (coordenada A, coordenada B) [1]
função (coordenada A, coordenada B, coordenada C) [2]
Este trabalho abordará as imagens 2-D. Uma imagem digital é representada no
sistema computacional como uma matriz, as interseções linha por coluna desta matriz
armazenam informações sobre a imagem. Tais informações podem ser: a intensidade do nível
de cinza, as intensidades das cores RGB ou, o índice da pallete de cores.
Os pontos de intersecção da matriz são chamados de pixels, uma abreviação de
picture element (SCURI, 2002). O tamanho e a quantidade de pixels de uma imagem
dependem de sua resolução espacial. A resolução é definida por diversas medidas a depender
do sistema de exibição ou tratamento da imagem. Uma das medidas é o DPI (dots per inch)
que define a razão de pontos por polegada linear (2,54 cm) na superfície da imagem.
20
Resoluções maiores resultam em imagens com maior quantidade de pixels. Quanto maior a
quantidade de pixels maior a complexidade computacional necessária para realizar
tratamentos na imagem. A figura 1 apresenta duas imagens que possuem o mesmo tamanho,
porém resoluções diferentes. É possível verificar que o círculo na imagem da direita possui
contornos mais definidos, resultado do tamanho de pixel ser menor e por conseqüência maior
grade de pixels.
Figura 1 - Imagens digitais com tamanho igual e resolução diferente (SCURI, 2002)
O tratamento de pixels é feito a partir de sua topologia. De acordo com as funções
que estão sendo aplicadas o pixel pode ser considerado como único, vizinhança 4 ou
vizinhança 8. Observando a figura 2 que representa 9 pixels de uma imagem pode-se
identificar as estratégias: em cinza claro nota-se a estratégia de tratamento do pixel como
único. Vizinhança 4 é definido pelo pixel cinza claro e os cinzas escuros que tocam o central
pelas laterais. Já a vizinhança 8 é definida como a figura toda, o pixel central e seus vizinhos
verticais, horizontais e diagonais (SCURI, 2002). Essa abordagem é válida para imagens com
grade de pixels regulares, grades hexagonais têm abordagem semelhante, mas não se
compõem como foco deste trabalho.
O sistema de coordenadas de uma imagem digital e dos dispositivos de exibição é
invertido verticalmente com relação ao sistema cartesiano ortogonal padrão. Ou seja, o ponto
de origem é encontrado na extremidade esquerda superior.
21
Figura 2 - Representação da vizinhança de um pixel
1.3 Processamento de Imagens Digitais
A área de Processamento de Imagens Digitais visa o tratamento dessas com dois
objetivos: “melhoria da informação visual para interpretação humana e o processamento de
dados das cenas para percepção automática através de máquinas” (GONZALEZ; WOODS,
2000, p. 01). O processamento de imagens tem seu campo de aplicação nas imagens digitais,
ou seja, imagens discretizadas em função de coordenadas bidimensionais, como explicitado
na função definida em [3], que armazenam os valores correspondentes ao brilho, em imagens
em tons de cinza, ou o valor correspondente à cor naquela posição, em imagens coloridas.
f(x,y). [3]
O processamento de imagens é composto por três níveis de processamento, como
exibido na figura 3 retirada de (GONZALEZ; WOODS, 2000). Nem todos os passos descritos
na figura 3 precisam ser executados, dependendo do domínio de aplicação. Entretanto os
passos descritos sugerem o método mais eficiente para maximizar o reconhecimento dos
padrões constantes da imagem.
O processamento de baixo nível engloba as fases de aquisição e pré-
processamento. Filtragem, restauração, mudança do domínio, compressão. As atividades que
compõem este nível não necessitam da supervisão humana, tampouco da utilização de rotinas
ou equipamentos sofisticados, em termos de inteligência computacional (GONZALEZ;
WOODS, 2000).
22
Figura 3 - Níveis de Processamento (GONZALEZ; WOODS, 2000, p. 408)
A aquisição de imagens que será abordada neste trabalho dá-se a partir da
discretização de cenas tridimensionais. O processo de captura é realizado por câmeras ou
scanners. No caso das câmeras, a representação 2-D é obtida a partir da captura da energia
luminosa desprendida do objeto. Essa energia “é convertida em sinal elétrico pelo
dispositivo” (CONCI; AZEVEDO; LETA, 2008, p. 53).
Com esta conversão é possível representar a imagem como uma matriz de dados,
ou pixels (picture element), onde são guardadas as informações de cores, luminosidade ou os
índices para palletes de cores. Tal processo é necessário para que se possam manipular as
representações dos sinais contínuos no computador, como explicitado por Scuri (2002, p. 14):
“a discretização de qualquer sinal contínuo primeiro passa por uma amostragem e
depois passa por uma quantização. Além disso, não podemos armazenar um sinal
que se estenda indefinidamente, portanto o sinal digital também é limitado a um
intervalo do domínio.”
A atividade de filtragem é realizada buscando um melhoramento da imagem de
acordo com o domínio da aplicação. A imagem pode ser melhorada em termos visuais quando
23
a análise é efetuada por indivíduos humanos. Podem ser realizados melhoramentos, em
termos de realce de características, dentre elas bordas, linhas, cores, texturas, etc.
A atividade de restauração é realizada quando a imagem apresenta falhas
decorrentes de sua aquisição. Ruídos de movimento, correção de foco, etc. Seus resultados
são melhor apreciados para sistemas destinados à visualização humana (SCURI, 2002).
A mudança de domínio é realizada antes da aplicação de filtros sobre a imagem.
Utiliza-se em geral a Transformada de Fourier, ou sua variante rápida. “Esse grupo de
operações é visto somente em programas de processamento de imagens científico” (SCURI,
2002, p. 86). A compressão de imagens é realizada visando a geração de arquivos mais leves.
Em geral é aplicada para facilitar o transporte das imagens.
O processamento intermediário requer uma intervenção humana ou de um sistema
inteligente. Visto que o resultado desse processamento é determinante para um correto
reconhecimento e depende de quais características se deseja extrair da imagem.
1.3.1 Segmentação
O termo segmentar refere-se à divisão em segmentos, sendo tal segmento uma
parte do todo (DICIONÁRIO MICHAELIS, 2000). Na área de Processamento de Imagens
define-se segmentação como a ação que visa dividir uma imagem nas suas partes ou nos
objetos constituintes dessa imagem (GONZALEZ; WOODS, 2000). Estas novas porções da
imagem contêm as características de interesse ressaltadas das demais, facilitando um processo
de reconhecimento, análise ou interpretação (CONCI; AZEVEDO; LETA, 2008).
O processo de segmentação, portanto, tem como objeto obter uma determinada
região da imagem que possua características relevantes maximizadas para o domínio de
aplicação. O ato de segmentar é feito buscando separar da imagem original regiões que
possuam características em comum. A segmentação pode ser implementada visando a
separação de cores, texturas, pontos, linhas, descontinuidades, bordas, dentre outros
24
(GONZALEZ; WOODS, 2000). Portanto, áreas que possuam características semelhantes,
ainda que descontínuas na imagem original, podem ser separadas.
De acordo com o tipo de segmentação implementado na imagem esta pode chegar
a ser dividida em duas regiões, o fundo e o objeto. Em geral definidos em branco e preto, são
as imagens binárias. Ainda que a imagem seja composta por tons de cinza, as imagens
segmentadas possuem uma quantidade menor de características. A bibliografia cita as
imagens binárias como resultados melhores para uma segmentação devido a redução
significativa da quantidade de dados (ALBUQUERQUE; ALBUQUERQUE , 2000).
O presente projeto adotou a divisão dos autores Gonzalez e Woods (2000) para
citar as diversas formas de segmentação. Os autores foram escolhidos por terem desenvolvido
uma lista de algoritmos que abrange um escopo de segmentação, para imagens em tons de
cinza, amplo e que inclui as definições dos demais autores utilizados como referencial teórico.
Os principais algoritmos de segmentação para imagens monocromáticas são baseados em
descontinuidade ou similaridade dos níveis de cinza.
1.3.1.1 Segmentação por Descontinuidade
Algoritmos baseados em descontinuidade executam a separação da imagem a
partir da identificação de inconsistências na distribuição do nível de cinza. Esses algoritmos
utilizam três tipos de estruturas para determinar essas inconsistências: pontos, linhas e bordas.
A atividade de segmentação por descontinuidade envolve a utilização de filtros
para varrer a imagem e identificar as estruturas. Tal identificação pode ocorrer tanto no
domínio de freqüência quanto no domínio espacial.
Na detecção de pontos, a máscara utilizada possui um valor elevado na célula
central e valores extremamente baixos nas outras células, como exibido na figura 4 (a).
Assim, quando a máscara for aplicada sobre a imagem os pontos serão destacados na imagem
final, pois “o nível de cinza de um ponto isolado é completamente diferente do nível de cinza
de seus vizinhos” (GONZALEZ; WOODS, 2000, p. 296).
25
Figura 4 - Máscaras:(a) detecção de pontos e de linhas (b) Horizontal (c) Vertical (d) +45º (e) -45º
Para detecção de linhas são utilizadas quatro máscaras, semelhantes às utilizadas
na detecção de pontos. Nesta operação, porém, utilizam-se quatro máscaras capazes de
detectar as linhas na posição horizontal, vertical e nas diagonais de 45º (positivo e negativo).
São definidos valores elevados para as linhas de detecção da máscara, e valores constantes
para as outras células. Exemplos de máscaras de detecção de linhas podem ser vistas na figura
4 (b) a (e).
A detecção de bordas é a abordagem mais utilizada para segmentação por
descontinuidades, “a razão é que pontos e linhas finas isoladas não são ocorrências
freqüentes” (GONZALEZ; WOODS, 2000, p. 297). A borda é a delimitação dos objetos na
imagem, são caracterizadas pela mudança repentina dos níveis de cinza, “Os pontos de borda
caracterizam as transições entre objetos diferentes” (FONSECA, 2000, p. 93).
Nessa abordagem de detecção os operadores de Roberts, Sobel, Laplaciano,
dentre outros algoritmos de detecção de borda são extensamente utilizados. Podendo ser
seguidos ou precedidos de uma limiarização.
Limiarização (threshold) é o processo de definição de um nível de cinza dentro da
imagem que se tornará a fronteira definindo quais pixels serão ‘acesos’ ou ‘apagados’.
Resulta numa imagem binária e é, em geral, definido baseando-se no histograma da imagem.
O histograma é o indicador percentual da quantidade de pixels com determinado tom de cinza
ou intensidade de cor na imagem, a figura 5 exibe dois exemplos de histogramas. De acordo
com o agrupamento dos pixels na imagem e com o objetivo do tratamento da imagem (separar
objetos do fundo, identificar bordas) o ponto de corte é escolhido (CONCI; AZEVEDO;
LETA, 2008).
26
Figura 5 - Exemplos de Histograma (LEITE, 2004)
O operador de Roberts é um dos algoritmos mais simples para detecção de bordas,
no entanto é muito sensível aos ruídos existentes na imagem (SEARA, 1998). O algoritmo de
Sobel ou Operador de Sobel utiliza duas máscaras 3x3 que são aplicadas na imagem visando a
detecção das linhas horizontais e verticais. A figura 6 exibe um exemplo do operador de
Sobel. Os algoritmos de Sobel e Roberts podem ser definidos como um único operador
Gradiente, quando são aproximados por filtros 3x3 e a partir das fórmulas [4] e [5], onde xG
e yG são as máscaras utilizadas em Roberts [4] e Sobel [5] e mostradas na figura 6 (d) e (e),
respectivamente.
22|| yx GGG += [4]
|||||| yx GGG += [5]
O operador Laplaciano utiliza uma máscara padrão definida na figura 7, é um
algoritmo muito suscetível ao ruído, porém extremamente eficaz na detecção de bordas em
qualquer direção (NEVES; PELAES, 2001).
27
Figura 6 - (a) Imagem tratada com um filtro ,(b) operador de Roberts ,(c)operador de Sobel e exemplos de
máscaras utilizadas em (d) Roberts e em (e) Sobel. (FELGUEIRAS, 2007, alterada)
Figura 7 - Máscara utilizada no operador Laplaciano
1.3.1.2 Segmentação por Similaridade
A detecção de regiões de interesse por similaridade baseia-se em três abordagens
principais: limiarização, crescimento de regiões e fusão e divisão de regiões. O processo de
limiarização aplicados a segmentação por descontinuidade descrita anteriormente é o tipo
mais simples de limiarização. Este tipo de limiarização utilizando o histograma é também
chamado de limiarização global e só apresenta resultados ótimos, em geral, quando é possível
controlar a iluminação da cena (GONZALEZ; WOODS, 2000).
28
A figura 8, retirada de Leite (2004), demonstra como o algoritmo de limiarização
pode ser eficiente e como o controle de iluminação o afeta. Na imagem original em tons de
cinza a identificação da placa é impossível, após a aplicação da limiarização os 4 números e a
segunda letra que compõem a placa podem ser vistas claramente, porém a primeira letra é
totalmente apagada e a terceira apresenta-se como um borrão. Em caso de uma iluminação
consistente na região da placa, esse problema seria evitado.
Figura 8 - Exemplo da aplicação da limiarização (a) Imagem original em tons de cinza (b) Imagem
binarizada por limiarização (LEITE, 2004)
Crescimento de regiões é um procedimento que visa o agrupamento de regiões a
partir de uma sub-região determinada. ”Regiões homogêneas em relação ao predicado e
adjacentes no espaço são agrupadas” (CONCI; AZEVEDO; LETA, 2008, p. 203). O
procedimento inicia-se a partir da definição de uma sub-região que contém as características
(cor, textura, nível de cinza) desejadas para a extração do objeto de interesse, o algoritmo
agrega todos os pixels semelhantes a esta região semente até que nenhum pixel em contato
com os pixels da região apresente as características desejadas. Podem ser definidas mais de
uma sub-região semente (CONCI; AZEVEDO; LETA, 2008).
Esse procedimento apresenta algumas dificuldades que são determinantes para o
sucesso da utilização do método. A escolha da sub-região semente, que deve possuir as
características adequadas e o critério de similaridade para agregação de novos pixels
(GONZALEZ; WOODS, 2000). A flexibilidade desses critérios pode acarretar em uma região
final maior ou menor que a esperada. Usualmente são utilizados conjuntos de descritores
29
baseados em “intensidade e em propriedades espaciais” (CONCI; AZEVEDO; LETA, 2008,
p. 204) decorrentes de um grupo de imagens. Além desses o algoritmo deve estar preparado
para lidar com a conectividade e com a adjacência para que a região seja corretamente
definida.
A técnica de fusão e divisão de regiões consiste na divisão da imagem em 4
quadrantes, os pixels de cada quadrante são verificados para definir se atendem ao critério de
homogeneidade definido. Em caso de atendimento de todos os pixels o quadrante é
estabelecido como região e não são mais tratados pelo algoritmo, os blocos que não atendem
ao critério são novamente divididos em quatro blocos.
O algoritmo desse procedimento é geralmente associado a uma estrutura quadtree,
uma árvore onde cada nó possui quatro descendentes. (CONCI; AZEVEDO; LETA, 2008).
Após a aplicação do algoritmo as regiões que atendam ao critério de homogeneidade e que
estejam conectadas são unidas.
1.3.2 Morfologia Matemática
Morfologia Matemática é a área de Processamento de Imagens que analisa as
formas da imagem. É empregada quando existe a necessidade de extração de informações que
são compostas por formas topológicas ou geométricas. Morfologia tem sua origem nas
palavras gregas morphos que remete a formas e logia, que significa estudo (DICIONÁRIO
MICHAELIS, 2000). Portanto, morfologia é o estudo das formas, avançando para o estudo
das relações entre essas formas.
A Morfologia se constitui da utilização de transformações que são compostas por
operações elementares. Matematicamente é baseada na teoria dos conjuntos, geometria
integral e álgebra de reticulados (NEVES, 2003). É aplicada tanto em imagens em tons de
cinza quanto em imagens binárias.
As operações básicas da Morfologia são a Erosão e a Dilatação (GONZALEZ;
WOODS, 2000). A partir da combinação dessas alcança-se as operações de Abertura e
30
Fechamento. Para utilizar a morfologia é definida uma estrutura, denominada elemento
estruturante, que será utilizada nas operações com a imagem. O elemento estruturante
funciona como uma máscara a ser aplicada na imagem e, a depender do seu tamanho e forma
afeta a imagem de maneira diferente.
Segundo Neves “O elemento estruturante é um conjunto plenamente conhecido e
definido (forma e tamanho) usado para ser comparado ou medido na imagem a ser estudada a
partir de uma transformação” (NEVES, 2003, p. 14). A definição do elemento estruturante é
baseada na necessidade do domínio de aplicação e em alguns casos é necessário realizar
alguns testes até chegar à matriz que melhor resolva o problema. “Na maioria dos casos os
elementos estruturantes devem ser os mais simples possíveis e são escolhidos em função das
propriedades de convexidade, não convexidade, isotropia e anisotropia” (NEVES, 2003, p.
14). A figura 9 apresenta exemplos de elementos estruturantes.
Dougherty e Lotufo definem a morfologia matemática como um processamento
baseado em geometria, visto que “A idéia básica, decorrente da estereologia, é sondar uma
imagem com um elemento estruturante e quantificar a forma como o elemento estruturante se
enquadra (ou não se enquadra) dentro da imagem” (DOUGHERTY, LOTUFO, 2003, p. 1).
Sobre a importância da escolha do elemento estruturante para o sucesso da
operação morfológica os autores Dougherty e Lotufo são categóricos: “Toda a transformação
morfológica depende do conceito de montagem dos elementos estruturantes”
(DOUGHERTY, LOTUFO, 2003, p. 2).
Figura 9 - Exemplos de Elementos Estruturantes de formas comuns: (a) Cruz e o (b) Quadrado. (NEVES,
2003)
31
Neves (2003) define quatro tipos de elementos estruturantes mais utilizados nas
aplicações de morfologia matemática. São eles: segmentos de linhas, par de pontos, discos e
elementos compostos.
Podemos definir as operações morfológicas como uma análise entre as formas da
imagem e o elemento estruturante definido com consequente ajuste da forma (incremento ou
retirada de pixels). A erosão é a operação de eliminação de pixels que não se adequam às
formas do elemento estruturante. Sua ação erode a imagem de modo a aumentar os buracos e
eliminar formas menores que o elemento estruturante. Em movimento contrário está a
dilatação, que promove um aumento da imagem. “A dilatação expande uma imagem, enquato
a erosão a reduz” (GONZALEZ; WOODS, 2000, p.373). Na figura 10 estão exemplos de
erosão e dilatação, observar que o ponto estruturante utilizado na figura é circular, visível
somente em (ii).
Figura 10 - Exemplos de (ii) erosão e (iii) dilatação sobre a imagem apresentada em (i). (GONZALEZ;
WOODS, 2000)
Ainda na figura 10 é possível observar os símbolos matemáticos utilizados para
definir as operações de dilatação e erosão, explicitados em [6] e [7].
32
⊕ Dilatação [6]
Ѳ Erosão [7]
A utilização das operações de dilatação e erosão cria resultados pouco fiéis à
imagem original, para contornar essa característica desenvolveram-se as técnicas de abertura e
fechamento que visam resultados mais fiéis à imagem original, ainda que tenham passado por
tratamento. O objetivo dessas operações é suavizar os contornos das imagens que receberam
um tratamento morfológico, para isso as imagens erodidas são dilatadas e as imagens
dilatadas são erodidas, ou seja, submetidas à operação de abertura que consiste da aplicação
da erosão seguida da dilatação ou submetidas ao fechamento, dilatação seguida de erosão.
Figura 11 - Exemplos de (a) Abertura e (b) Fechamento. (GONZALEZ; WOODS, 2000)
Enquanto a abertura “quebra istmos estreitos e elimina protusões finas”
(GONZALEZ; WOODS, 2000, p.373) o fechamento “funde as quebras em golfos finos,
elimina pequenos buracos e preenche fendas em um contorno” (GONZALEZ; WOODS,
2000, p.373), essas operações suavizam os contornos da imagem. Como visto na figura 11, as
33
imagens finais são mais fiéis à imagem original ainda que apresentem as características da
erosão ou dilatação.
Além das operações citadas neste tópico, convém informar que a morfologia
matemática possui diversas outras transformadas especializadas em domínios de problemas
tais como a transformada hit-or-miss, segmentação morfológica através do algoritmo de
watershed, dentre outros. Tais operações foram omitidas do presente trabalho pois sua
utilização não está prevista na execução do projeto.
1.4 Reconhecimento de Padrões
Após a invenção da escrita, ao longo de vários séculos, o homem confiou a guarda
de suas informações à escrita e ao papel. Com a chegada dos computadores e mais
recentemente o advento da internet, a produção de informação passou a ser um processo mais
democrático. Crescendo em ritmo acelerado. Além da geração de novas informações tornou-
se claro que digitalizar informações já produzidas era um processo vantajoso tanto da visão
econômica quanto cultural.
No entanto, a digitalização e tratamento dessas informações é um processo ainda
em desenvolvimento. Um dos focos principais a ser abordado neste trabalho é a identificação
de caracteres a partir de imagens digitais. As principais dificuldades dessa ação são:
reconhecer os caracteres na imagem, diferenciar caracteres de formas, extraí-los de modo a
permitir sua edição. O processo é simples quando imaginamos o reconhecimento humano de
uma folha de papel datilografado que foi digitalizada, uma foto de um outdoor ou um rabisco
digital. Mas para o sistema computacional reconhecer caracteres nessas imagens, ele esbarra
em dificuldades tais quais: caracteres incompletos (como um “o” que foi deixado
parcialmente aberto pela falta de tinta), em ângulos diferentes (como palavras na vertical ou
em ângulos diagonais no outdoor), com formatações (negrito, itálico, tachado), formas no
meio (marcas que podem ser confundidas com caracteres), etc. O correto tratamento da
imagem visando a obtenção de um material consistente para o processamento é determinante
para o sucesso do processamento.
34
O processo de reconhecimento automático de caracteres a partir de uma imagem é
uma área englobada pelo reconhecimento de padrões. Padrão é uma “descrição quantitativa
ou estrutural de um objeto ou entidade...” (GONZALEZ; WOODS, 2000, p. 409). Pode-se
ainda afirmar que Padrão é um rótulo para definir o objeto dentro do conjunto (CARVALHO,
2005). Ainda podendo ser definido como “qualquer aspecto que pode ser padronizado em
uma estrutura armazenável” (CONCI; AZEVEDO; LETA, 2008, p. 260). A composição do
padrão não é de uma informação única e sim de um conjunto que estruturas que definem o
objeto a ser reconhecido. Gonzalez e Woods (2000) definem o Padrão como “um arranjo de
descritores”. Entende-se por descritores o conjunto de informações de uma região de interesse
da imagem. Tais informações podem conter medidas de comprimento, tipos de formas,
direção de linhas, consistência de pontos, informações de ângulos, etc.
Classes de Padrões são definidas como uma categorização de padrões que
possuem características comuns. Pode-se então definir reconhecimento de padrões como a
associação automática de padrões à suas classes por máquinas, onde não ocorra ou ocorra
minimamente ações humanas (GONZALEZ; WOODS, 2000).
Define-se Padrão como a descrição possível capaz de identificar e individualizar o
dado obtido dentro do conjunto e que possa ser armazenada em uma base de dados.
Especificamente para este trabalho Padrão será utilizado como descritor dos símbolos dos
caracteres alfanuméricos constantes do alfabeto ocidental. O alfabeto ocidental e o conjunto
de números decimais serão o conjunto básico para utilização na aplicação a ser desenvolvida.
Define-se esse conjunto como C contendo os seguintes elementos descritos em [8]. Dado será
tratado como o símbolo que representa o caractere ou letra no conjunto.
C={A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,0,1,2,3,4,5,6,7,8,9} [8]
1.4.1 Métodos de Abordagem
A área de Reconhecimento de Padrões em Processamento de Imagens tem dois
métodos principais para o reconhecimento: decisão teórica e estrutural. A diferença básica
entre os métodos é o modo como os padrões são representados, enquanto os métodos de
35
decisão teórica utilizam-se de vetores de padrões, também conhecidos como vetores de
características, os métodos estruturais utilizam representações de padrões em cadeias ou
árvores (GONZALEZ; WOODS, 2000).
As abordagens de decisão teórica utilizam funções de decisão para o
processamento, onde um padrão é dito reconhecido à classe de padrões se atender aos
critérios definidos nas funções de decisão. Os métodos de decisão teórica podem ser divididos
em abordagens de casamento, classificadores estatísticos ótimos e redes neurais. Abordagens
definidas como casamento são os classificadores de distância mínima e casamento por
correlação (GONZALEZ; WOODS, 2000). A idéia de casamento se deve a relação da
imagem, ou das informações com o vetor ser feita de maneira quase direta. Classificadores
estatísticos ótimos englobam os classificadores bayesianos, essa abordagem utiliza
probabilidades dos padrões pertencerem ou não a determinada classe de padrões. Por fim, a
abordagem de redes neurais, utiliza uma rede neural e algoritmos de treinamento para realizar
as classificações. Os métodos de decisão teórica utilizam padrões quantitativos da imagem.
Métodos estruturais observam as formas encontradas na imagem para realizar o
reconhecimento dos padrões (GONZALEZ; WOODS, 2000). As abordagens dos métodos
estruturais podem ser casamento de números de formas, casamento de cadeias e métodos
sintáticos. O casamento de número de formas utiliza uma árvore de formas e a partir dela
compara as fronteiras e regiões descritas na imagem (GONZALEZ; WOODS, 2000).
Casamento de cadeias utiliza o mesmo princípio do casamento de formas, porém utiliza
polígonos similares. Métodos sintáticos são a abordagem mais usual, utilizando um conjunto
de primitivas e regras, um autômato varre a imagem, primeiro considerando a gramática
formada pelas primitivas e regras (GONZALEZ; WOODS, 2000).
1.5 Linguagem Matlab
Para este trabalho adotou-se como linguagem de desenvolvimento o Matlab que é
a linguagem de programação utilizada pelo software Matlab® da The MathWorks™ e que
baseou a criação da variante utilizada pelo software Octave publicado sob a licença da Free
Software Foundation.
36
As duas linguagens de programação apresentam peculiaridades, enquanto a
linguagem Matlab da MathWorks é proprietária a variante apresentada pelo software Octave é
baseada na filosofia Open Source e se caracteriza por ser compatível com a linguagem
proprietária (OCTAVE, 2009).
Optou-se por utilizar as duas linguagens haja vista que as diferenças entre ambas é
mínima, necessitando apenas de ajustes nos códigos. Justifica-se também a escolha das duas
tendo em vista que os códigos do protótipo não fiquem atrelados à licenças de copyrights.
Pode-se observar como principais diferenças entre as linguagens (SCALON,
2008):
• A nomenclatura de algumas funções básicas utilizadas pelos compiladores
diferem. Por serem casos extremamente pontuais, a ocorrência desses
casos será sinalizada nos scripts.
• O Matlab reconhece comentários somente iniciados por ‘%’, por sua vez o
Octave aceita também comentários iniciados por ‘#’. Para evitar retrabalho
será utilizado o símbolo ‘%’ nos comentários.
• Para uma execução correta os blocos condicionais e de repetição (while, if,
for) e as funções necessitam de uma declaração ‘end’ ao fim do bloco. O
Octave por sua vez permite a utilização de ‘endif’, ‘endwhile’, ‘endfor’ e
‘endfunction’, Apesar da utilização da declaração do Octave deixar o
código com uma legibilidade melhor, será adotado o modo de declaração
do Matlab, para facilitar a manipulação dos códigos entre as ferramentas.
• Para declaração de desigualdades o Matlab aceita somente o ‘˜=’.
enquanto o Octave aceita também o ‘!=’. Novamente se dará preferência à
forma entendida por ambas as ferramentas.
• Por fim, operadores incrementais tais como ‘++’ ou decrementais, ‘--’, não
são reconhecidos pelo Matlab. Devido a isto seu uso foi substituído por
métodos incrementais.
A linguagem Matlab “permite implementar e resolver problemas matemáticos
muito mais rápida e eficientemente que através de outras linguagens como C, Basic, Pascal ou
37
Fortran.” (CBPF, 2002). Devido a sua capacidade de processamento matemático, a linguagem
é amplamente utilizada por diversas áreas das Ciências Exatas, desde engenheiros a
economistas utilizam-se da facilidade de lidar com matrizes ou manipulação algébrica.
Por fim, ambas as linguagens baseiam-se na linguagem C, linguagem de
programação esta que é amplamente difundida, fato que agrega ao protótipo uma ampla base
de potenciais colaboradores para revisões posteriores do código.
38
2. FERRAMENTAS DE DESENVOLVIMENTO
Este capítulo discorre brevemente acerca das ferramentas de desenvolvimento
utilizadas para construção do protótipo. A apresentação das ferramentas objetiva ser
imparcial, apresentando suas características relevantes para o trabalho, além de apresentar
sites que armazenem a documentação, o arquivo para download ou a página da empresa
responsável pelo produto.
Os tópicos tratam da ferramenta Matlab da MathWorks™, a ferramenta Octave da
Free Software Foundation, ambos utilizados como ambiente de desenvolvimento. Em seguida
é apresentado o banco de dados MySql da Sun Microsystems, utilizado como base de dados.
2.1 MathWorks™ Matlab
O software MathWorks™ Matlab é um ambiente de desenvolvimento que utiliza
a linguagem de programação de alto nível, Matlab, baseada na linguagem C. É um ambiente
que permite a criação, execução e manutenção dos códigos baseados nesta linguagem.
É um ambiente especializado em cálculos computacionais, em especial álgebra
linear, estatística, análises de séries de Fourier, filtragem, otimização e integração numérica
(MATHWORKS,2009). O software possui também uma facilidade na programação de
gráficos, em decorrência desses fatores o ambiente apresenta fatores que potencializam seu
uso em processamento de imagens. A figura 12 mostra a tela de apresentação do software.
39
Tabela 1: Sites com informações Matlab
Site Oficial http://www.mathworks.com/products/matlab/
Documentação http://www.mathworks.com/access/helpdesk/help/helpdesk.html
Release Detail R2009b
http://www.mathworks.com/products/new_products/latest_features.html
O software possui também a característica de agregar toolbox para funções
específicas, no caso de processamento de imagens, as toolbox utilizadas são Image Processing
Toolbox , Image Acquisition Toolbox e Mapping Toolbox . Essas toolbox possuem funções
específicas que auxiliam no desenvolvimento dos códigos.
Figura 12 - Tela inicial Matlab R2007b.
A versão atual do software é a R2009b, para este trabalho foi utilizada a versão
R2007b. A releases detail foi consultada e não se observou nenhuma incompatibilidade entre
as versões do software ou das toolbox. A tabela 1 exibe uma relação com os sites onde o
software pode ser encontrado
2.2 GNU Octave
O software livre GNU Octave é um ambiente de desenvolvimento que utiliza a
linguagem de programação de alto nível, GNU Octave, baseada na linguagem C e altamente
40
compatível com a linguagem Matlab da Mathworks.O software em si é mais simples que o
ambiente da Mathwoks, porém suas capacidades de cálculo computacional são semelhantes.
O Octave é especialista em cálculos computacionais, em especial álgebra linear,
integração de funções, manipulação polinomial e integração (OCTAVE, 2009). O software,
como no Matlab, possui uma facilidade para a manipulação de matrizes o que potencializa seu
uso em aplicações que realizem processamento de imagens.
Figura 13 - Tela inicial Octave 3.2.3.
A versão atual estável do software é a 3.2.3, que é a utilizada no projeto. Na figura
13 é exibida uma imagem da área de trabalho do Octave. Na tabela 2 é exibida a lista de sites
para acesso a informações do aplicativo. O software está sendo utilizado na compilação
binária para execução no Windows®.
Tabela 2: Sites com informações Octave
Site Oficial http://www.gnu.org/software/octave Documentação http://www.gnu.org/software/octave/docs.html Versão 3.2.3 http://www.gnu.org/software/octave/download.html
41
2.3 Base de Dados
Para a implementação da base de dados foi definido o banco de dados de código
aberto MySql, desenvolvido e mantido pela Sun Microsystems. A escolha desta ferramenta
deu-se após a análise de compatibilidade dos outros bancos de dados com as ferramentas de
desenvolvimento, a facilidade de uso e características complementares,
Um dos pontos que determinaram a escolha desse sistema de gerenciamento de
banco de dados (SGBD) foi a sua utilização prévia em outros projetos de pesquisa com a
ferramenta Matlab. A linguagem do banco, SQL, também motivou a escolha, observando que
o pesquisador possuía experiência com esta linguagem,
Por fim, por ser um software de código aberto e disponível gratuitamente (licença
GPL), o software se adequa as características deste projeto, como uma ferramenta de fácil
acesso para que ingressantes na área tenham acesso. O MySql “é atualmente um dos bancos
de dados mais populares” (SUN, 2009). Graças a essa difusão a sua comunidade de
desenvolvedores segue a filosofia Open Source e disponibiliza na internet diversos manuais,
scripts e fóruns.
2.4 Desenvolvimento de Interface com o Usuário
Para desenvolvimento da interface com o usuário não foi encontrada uma
ferramenta que realizasse esta tarefa nas duas ferramentas de desenvolvimento, Matlab e
Octave. A ferramenta Matlab possui internamente um componente que possibilita a criação de
interfaces intuitivas com o usuário. A Graphical User Interface (GUI) criada na ferramenta
do Matlab, entretando, utiliza bibliotecas e funções específicas do próprio software
impossibilitando sua utilização com o Octave.
Com objetivo de manter o protótipo resultante deste projeto possível de migração
entre plataformas de desenvolvimento e livre de uma tecnologia proprietária não será
desenvolvida uma interface na ferramenta supracitada. Entretanto, com o intuito de manter o
42
projeto com sua vertente pedagógica, o processo de construção da interface é descrito no
Anexo I - construção da interface.
43
3. DESENVOLVIMENTO DO PROTÓTIPO
Um dos principais objetivos deste trabalho é divulgar e incitar a adesão de novos
pesquisadores para a área de processamento de imagens. Com esta visão o trabalho foi
desenvolvido de modo que possibilitasse a absorção de conceitos básicos teóricos e práticos
pelo leitor.
Desta forma os códigos do protótipo foram desenvolvidos adotando um método
de facilidade de interpretação. Os códigos foram desenvolvidos em módulos, processamento
de nível básico e de nível intermediário.
Esse capítulo trata do desenvolvimento desses scripts, além de outros necessários
para a construção do protótipo. O tópico 3.1, destaca os módulos e os códigos desenvolvidos
nos mesmos, em seguida é descrito o método de integração os módulos no tópico 3.2. O
tópico subsequente, 3.3, trata da implementação da base de dados.
3.1 Módulos
No desenvolvimento do Protótipo foi observado a necessidade de utilizar
processamento de baixo nível e de nível intermediário. Para efeitos de organização foram
estabelecidos módulos de processamento básico, morfologia e segmentação.
O módulo de processamento básico contém scripts que tratam de adição e
subtração de imagens, histograma e equalização, O módulo de processamento intermediário
44
que trata da morfologia é composto por scripts que tratam de abertura e fechamento e
esqueletonização. Os outros scripts do módulo tratam da segmentação, detecção de linhas na
imagem e extração de bordas.
Essa divisão em módulos foi realizada com intuito de facilitar o estudo dos
códigos. Internamente o protótipo não possui essa separação. Para o protótipo utilizou-se a
divisão em scripts para imagens binárias e para imagens rgb ou em tons de cinza, Essa
separação foi implementada visando observar os resultados nos dois grupos de imagens,
facilitando os testes. Ainda considerou-se que os dispositivos fotossensores geram imagens
em somente um dos grupos, rgb, portanto os códigos para imagens binárias podem ser
considerados somente com efeito didático.
O módulo de processamento básico possui funções que não são implementadas
automaticamente por nenhuma das ferramentas de desenvolvimento. Por esse motivo, funções
de aquisição, erosão, dilatação, exibição de imagens não foram priorizadas. As funções que
constam neste módulo são:
• Adição: Função para adição de imagens. São fornecidas duas imagens que
serão adicionadas. É utilizada para minimizar ruídos existentes na
imagem, a partir da soma destas e da média aritmética;
• Subtração: Função para subtração de imagens. São fornecidas duas
imagens onde a primeira será subtraída da segunda. Utilizada para
identificar movimentos em imagens sequenciais, ou eliminar padrões da
imagem, pode ser utilizada também para retirada de certos tipos de ruído;
• Histograma: Em processamento de imagens, o histograma é a distribuição
dos níveis de cinza na imagem. Como entrada é fornecida a imagem e a
saída é o gráfico de histograma da mesma;
• Equalização: Função que resulta numa imagem com melhor distribuição
dos níveis de cinza. Busca um histograma mais uniforme, via de regra
resulta numa imagem com melhor contraste. É fornecida a imagem e
temos como saída a imagem e seu histograma equalizado.
45
O módulo de processamento intermediário possui funções que são componentes
da morfologia matemática e de segmentação.
• Abertura: Função morfológica de abertura. É fornecida a imagem e a saída
é a imagem processada;
• Fechamento: Função morfológica de fechamento. É fornecida a imagem e
a saída é a imagem processada;
• Esqueletonização: A esqueletonização é realizada a partir do fornecimento
de uma imagem, no processamento são realizadas iterações de afinamento
e por fim são aplicadas erosões e dilatações, a saída é o esqueleto da
imagem.
• Detecção de linhas: A detecção de linhas é uma das abordagens da
detecção de segmentação por descontinuidade. Foram criados 5 scripts
para a detecção de linhas, eles tratam da detecção de linhas horizontais,
verticais, diagonais 45º positivos e negativos e todas. As funções diferem-
se por uma letra no final, ou seja, para todas as linhas a função é linhas,
para linhas verticais, linhasv, etc.;
• Detecção de bordas: Similar a detecção de linhas, utiliza uma abordagem
diferente utilizando uma função comum as duas ferramentas de
desenvolvimento, a função edge, e a aplicação de um filtro da média;
• Segmentação: Para a segmentação é fornecida a imagem, e o algoritmo
processa a partir dos elementos conectados, fornecendo ao final a imagem
segmentada com as bordas dos objetos (caracteres) destacadas. Esse script
foi baseado no algoritmo de Jeny Rajan e Chandrashekar (2006).
Os códigos implementados encontram-se no Apêndice C – códigos da
implementação.
3.2 Integração dos Módulos
O modo como os módulos seriam integrados dependeria da criação de uma
interface portável para ambas as plataformas de desenvolvimento. Como não foi possível
chegar a esta solução, optou-se por não realizar uma integração real entre os módulos e
46
scripts. Os testes do protótipo foram realizados executando cada script conforme necessário
para chegar ao resultado final.
3.3 Implementação da Base de Dados
Para a base de dados foi definido a utilização do banco de dados MySql, onde
foram criadas as tabelas com informações para conferência dos dados das imagens e para
guardar as informações extraídas.
Para a conferência das informações foram criadas as tabelas “pro_letra”, com duas
colunas, id_letra e letra e populada com as letras do alfabeto ocidental, como descrito em [9].
Uma segunda tabela foi criada para armazenar os números, “pro_num”, também com duas
colunas, id_num e numero, a sua constituição pode ser observada em [10]. Ressalta-se que os
valores descritos em [9] e [10] representam as tabelas populadas e que cada valor separado
por vírgula representa uma linha da tabela. Tendo, portanto a tabela “pro_letra” 26 tuplas e a
tabela “pro_num” 10 tuplas. A coluna referente aos identificadores das tuplas, “id_letra” e
“id_num”, foram configuradas como obrigatórias e com autoincremento, a iniciar do valor 01.
{A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z} [9]
{0,1,2,3,4,5,6,7,8,9} [10]
Foi criada uma terceira tabela para armazenar os dados extraídos da imagem,
“ext_dados”. Nessa tabela foram criadas onze colunas, descritas na tabela 3. uma coluna para
identificação da tupla, sete colunas para identificação das posições dos caracteres na placa e
três colunas para administração da informação, data e hora de extração e arquivo de origem.
Para conexão entre o aplicativo Matlab foi utilizado um script de conexão pronto
desenvolvido por Luigi Rosa e disponível no seu próprio Website. A decisão de utilizar um
script já pronto baseou-se no fato de que as tecnologias associadas ao scripts são gratuitas, a
linguagem Php e o próprio MySql, e a possibilidade de portabilidade para o Octave. Existem
toolboxes no Matlab que automatizam a conexão, mas não existem similares disponíveis para
47
o Octave, impossibilitando a utilização sem ferir os objetivos gerais do projeto. O script para
Matlab está no Anexo II - conexão com o banco.
Tabela 3: Descrição das colunas da tabela “ext_dados”
Nome da coluna Tipo de dado armazenado
Descrição da informação armazenada
id_dado Numérico Identificador do dado extraído pos_01 Caracter Valor da primeira posição da placa – primeira letra pos_02 Caracter Valor da segunda posição da placa – segunda letra pos_03 Caracter Valor da terceira posição da placa – terceira letra pos_04 Caracter Valor da quarta posição da placa – primeiro número pos_05 Caracter Valor da quinta posição da placa – segundo número pos_06 Caracter Valor da sexta posição da placa – terceiro número pos_07 Caracter Valor da sétima posição da placa – quarto número data Data Data da extração da informação hora Hora Hora da extração da informação arquivo Caracter Nome do arquivo onde a informação foi extraída
48
4. TESTES
Este Capítulo documenta os testes realizados no protótipo para garantia de seu
perfeito funcionamento. A definição de quais testes realizar, os métodos realizados e os
critérios de aceitação tiveram como base a experiência do pesquisador na área de testes.
O capítulo está dividido em definição da massa de testes a ser utilizada, a
documentação da realização dos testes, os critérios de aceitação para que o protótipo fosse
considerado como satisfatório e a compilação dos resultados obtidos.
4.1 Massa de Teste
A massa de testes a ser utilizada para validação do correto funcionamento dos
scripts desenvolvidos é composta de imagens em formatos que utilizem o algoritmo de
compressão do Joint Photographic Experts Group (JPEG) para imagens RGB e em tons de
cinza e para imagens binárias foi dado preferência a imagens com a extensão Portable
Network Graphics (PNG). Os formatos foram escolhidos por serem formatos livres,
amplamente difundidos em sua utilização. O formato JPEG, que é composto de imagens com
extensões “.jpeg”, “jpe”, “jpg”, “jfif” e “.jfi”, é utilizado por grande parte dos equipamentos
de geração de imagens, tais como máquinas fotográficas e equipamentos fotossensores, por
apresentar um bom nível de compressão. A extensão “.png” foi escolhida para as imagens
binárias por ser de fácil criação de imagens desse tipo.
As imagens utilizadas para os testes variam em sua resolução. Possuem
resoluções entre 100x68, para a menor imagem, e 640x240, para a maior. A massa de testes
49
foi dividida em três grupos, massa de imagens básicas, para testes em tempo de codificação e
para imagens que foram utilizadas para calibração de algoritmos. Composta por vinte e quatro
imagens, a figura 14 mostra algumas dessas imagens. O segundo grupo de imagens definido
foi o grupo de imagens de calibração, composto por seis imagens semelhantes às imagens
geradas por barreiras eletrônicas, para este grupo foram utilizadas fotos de modelos de placas
dispostas na imagem em diferentes posições, fotos da região traseira de carros emplacados,
focalizando a área da placa e foram criadas algumas imagens binárias com uma sequência de
letras e números, semelhante a utilizada para identificar as placas, com números e letras
escolhidos aleatoriamente. Essas imagens possuem em torno dessa sequência uma borda, com
diferentes características e falhas para possibilitar o treinamento de funções de segmentação
por região da placa. Todas as imagens que compõem a massa de teste estão documentadas no
Apêndice D – massa de testes.
Figura 14 – Exemplos de imagens da massa de testes básica. Caracteres (i, ii e iii) e linhas(iv, v, vi, vii, viii)
Figura 15 – Exemplos de imagens de calibração. Criada (i, ii e iii) e simulação(iv, v, vi,)
50
Por fim, o último grupo é composto por imagens que uma barreira eletrônica gera,
Foram utilizadas 20 imagens da base de imagens do projeto de reconhecimento de placas de
veículos brasileiros do Centro Brasileiro de Pesquisas Físicas (CBPF/MCT) e da Empresa
DRV - Desenvolvimento e Representação Ltda. Essa Base de imagens é fornecida
gratuitamente na página do grupo. As figuras 15e 16 mostram as imagens do grupo de
imagens de calibração e das imagens da base de imagens do CBPF/MCT.
Figura 16 – Exemplos de imagens utilizadas no teste provenientes da base de imagens do CBPF/MCT
Os grupos de imagens foram definidos de forma que cada grupo fosse capaz de
detectar e especializar os códigos escritos. Inicialmente utilizando imagens simples que
resultassem em saídas que definam o código como implementado com sucesso ou não. O
grupo de calibração tem por objetivo verificar se os códigos estão prontos para serem
aplicados em imagens com maior quantidade de características. As imagens reais da base de
imagens são a etapa de validação dos códigos.
4.2 Realização dos Testes
A metodologia adotada para realização dos testes englobou um teste exploratório
das funções a partir das massas de teste pré-estabelecidas. De acordo com a saída fornecida
após o código ser exercitado, este é considerado atendendo aos requisitos ou não atendendo.
Os testes foram realizados nas ferramentas de desenvolvimento, após os códigos
terem sido pré-testados em tempo de desenvolvimento. A atividade de testes consistia do
preenchimento de um checklist para verificar se o código atendia aos requisitos do projeto.
51
Inicialmente o arquivo do código era aberto e verificado se o código possuía
cabeçalho e comentários que possibilitassem o entendimento dos objetivos da função. Em
seguida o arquivo fonte era copiado para a área de trabalho do software de desenvolvimento,
nos dois softwares era criada uma pasta. A partir da ferramenta de desenvolvimento era
executada uma chamada da função com o fornecimento do nome do arquivo da imagem.
Após o processamento o arquivo de saída exibido era armazenado a partir de printscreen para
ser posteriormente analisado.
Códigos que não exibissem um arquivo de saída quando este é esperado ou que
relatassem erros impeditivos em tempo de execução foram considerados com o identificador
“bloqueado”. Quando a função não alcançava o objetivo esperado ou atingia resultados
desastrosos, o arquivo era considerado com erro do tipo “crítico”. Após a identificação de
erros os arquivos foram submetidos a uma nova análise para verificar quais os pontos que
provocaram o erro.
A manutenção dos identificadores dos códigos em tempo execução de testes foi
realizada em uma planilha no formato Excel. Nesta planilha ficou registrado o histórico de
erros que o código apresentou e a solução encontrada, de modo que ao final do projeto o
documento pudesse ser usado para extrair as melhores práticas de desenvolvimento. A figura
17 mostra um exemplo de preenchimento da planilha de controle. Os registros dos testes
foram armazenados em formatos jpeg,
Figura 17 – Exemplo da planilha de rastreabilidade dos identificadores dos códigos.
4.3 Critérios de Aceitação dos Scripts
Um script será considerado como pronto e com desempenho satisfatório se:
• Para o grupo de imagens básicas obtiver sucesso em todos os processos;
52
• Para o grupo de imagens reais obter sucesso em 80% das imagens.
O grupo de imagens de calibração não será contabilizado como mecanismo de
validação dos scripts. Os percentuais definidos como critérios de aceitação foram baseados na
experiência profissional do pesquisador na área de teste de software, haja vista que não
existem trabalhos realizados com o objetivo de mensurar, em termos quantitativos, o sucesso
ou fracasso de um código que implemente funções de processamento de imagens.
4.4 Resultados Obtidos
Após a realização dos testes os resultados dos códigos fonte foram considerados
satisfatórios. Erros de bloqueio foram identificados, mas corrigidos rapidamente, nenhuma
função chegou ao final dos testes apresentando erros críticos como exibido na tabela 4.
O módulo de processamento básico apresentou resultados de 100% de sucesso
tanto no grupo de imagens básicas quanto no grupo de imagens reais. As funções
componentes deste módulo são: adição, subtração, histograma e equalização.
Tabela 4: Resultado após os testes dos scripts
Função Imagens binárias Imagens RGB Identificação final abertura sucesso sucesso Código válido adicao sucesso sucesso Código válido borda sucesso sucesso Código válido esqueleto sucesso - Código válido equalizacao sucesso sucesso Código válido fechamento sucesso sucesso Código válido histograma sucesso sucesso Código válido linhas sucesso sucesso Código válido linhas45n sucesso sucesso Código válido linhas45p sucesso sucesso Código válido linhasv sucesso sucesso Código válido linhash sucesso sucesso Código válido segmentacao sucesso sucesso Código válido subtracao sucesso sucesso Código válido
O módulo de processamento intermediário atingiu também 100% de sucesso na
realização dos testes. Destaca-se, entretanto, que a utilização dessas funções em imagens com
53
grande número de características não leva ao resultado ótimo sem o tratamento prévio da
imagem, em especial na detecção de linhas em apenas uma das direções. A função de
segmentação definida aqui apresenta resultados similares a detecção de bordas, porém como
suas abordagens diferem os resultados apresentam diferenças.
Foi observado durante a realização dos testes que as duas ferramentas de
desenvolvimento apresentam resultados distintos para a mesma imagem de entrada. Isso
explica-se pela ferramenta que cada software usa para exibir as imagens resultantes. De
acordo com os resultados observados, a ferramenta que o Matlab utiliza para exibir as
imagens resultantes, retorna imagens em um formato próprio da mesma, “.fig”, enquanto que
a ferramenta do Octave retorna a imagem pura. Apesar dessas distorções os resultados finais
quando comparados demonstram as características esperadas antes da execução dos códigos.
Os principais resultados alcançados foram, para o módulo de processamento
básico:
Adição: Para esta função esperava-se que as imagens fornecidas como entrada
fossem somadas. Nas imagens binárias onde houvesse dois pixels pretos (1), ou dois pixels
brancos (0) o valor se manteria no pixel da imagem resultante. Onde não ocorresse o mesmo
valor o pixel na imagem resultante receberia o valor (0). Para imagens em RGB essa função
não foi projetada para funcionar como uma soma efetiva, por isso a sua aplicação em imagens
distintas leva a uma imagem em branco. Todavia, a função pode ser adaptada para a utilização
em uma única imagem, que após a soma seja aplicado o filtro da média. A função de adição
removeria um ruído existente na imagem, para tanto o comando para aplicação do filtro está
comentado no arquivo fonte. A figura 18 exibe o resultado da soma de imagens binárias com
a função executada no Matlab e com o mesmo resultado no Octave.
Figura 18 - Adição das imagens (i) e (ii), resultando em (iii). Função executada no Matlab.
54
Subtração: Nesta função o resultado esperado era uma imagem que mantivessem
os pixels com valores iguais nas duas imagens. Qualquer diferença de valores o valor do pixel
na imagem final seria preto (1). Para imagens RGB esta função não foi preparada. Haja vista
que sua aplicação para o protótipo não se aplica, entretanto o arquivo base pode ser estendido
para essa aplicação com um tratamento adequado de valores limítrofes. A figura 19 exibe o
resultado de uma subtração de imagens binárias com a função executada no Matlab e com o
mesmo resultado no Octave.
Figura 19 - Subtração das imagens (i) e (ii), resultando em (iii). Função executada no Matlab.
Histograma: A saída esperada dessa função é um gráfico que exiba a quantidade
de pixels com determinado valor na imagem. Para imagens binárias esse gráfico ficará
polarizado nos dois extremos, 0 e 1, quanto a imagens RGB, essas seriam transformadas em
tons de cinza, se já não estivessem nesse modo, e o gráfico resultante exibiria a quantidade de
pixels nos 256 tons de cinza possíveis. Por não serem realizadas operações sobre imagens em
RGB puro, não foi vista a necessidade da implementação do histograma que exibisse os
valores nas três bandas.
A figura 20 exibe um exemplo de histograma de uma imagem da base de dados
com a função executada no Matlab e na figura 21 pode ser visto o resultado para a execução
em uma imagem binária, neste caso realizada no Octave. Pode-se observar que apesar da
diferença nas ferramentas de exibição, o resultado está de acordo com as características das
imagens de entrada.
55
Figura 20 – Histograma (ii) da imagem(i) com a função executada no Matlab.
Figura 21 - Histograma (ii) da imagem binária (i) com a função executada no Octave.
Equalização: Para a função de equalização a saída esperada é um histograma
equalizado, ou seja, processado para que os tons de cinza sejam uniformemente distribuídos.
Além do histograma é esperada a exibição da imagem equalizada. A figura 22 mostra a
imagem original, a imagem 23 mostra o histograma da imagem antes da equalização,
enquanto as figuras 24 e 25 mostram, respectivamente, a imagem equalizada e o histograma
equalizado.
Figura 22 – Imagem original proveniente da base de imagens.
56
Figura 23 - Histograma da imagem 22 sem equalização.
Figura 24 – Imagem equalizada proveniente da execução da função no Matlab na imagem exibida na figura
22.
Figura 25 – Histograma equalizado da imagem 23 – execução no Matlab
57
Para o módulo de processamento intermediário os principais resultados obtidos
foram:
Abertura: A imagem resultante da aplicação desta função seria uma imagem com
contorno suavizado e sem ligações finas (istmos). O resultado pode ser visto claramente na
figura 26, principalmente na letra “M”. Na figura 27 é exibida a aplicação em uma imagem
em tons de cinza, onde é mais difícil visualizar a aplicação da função. Mas ao se observar as
bordas da imagem, percebe-se a suavização. Resultados ótimos da adição são perceptíveis
após o tratamento da imagem original, e na imagem da figura 20.2 não foi realizado nenhum
pré-tratamento.
Figura 26– Resultado (ii) da aplicação da função de abertura em uma imagem binária (i) no Octave.
Figura 27 – Resultado (ii) da aplicação da função de abertura em uma imagem em tons de cinza (i) realizada
no Matlab.
58
Fechamento: A imagem resultante neste caso seria uma imagem também com
contorno suavizado porém com as ligações preenchidas, além de ter seus buracos e baías
fundidos. A figura 28 exibe o resultado da aplicação da função em uma imagem binária,
enquanto a figura 29 exibe a mesma função aplicada numa imagem em tons de cinza,
observa-se que o Octave retorna a imagem binarizada, diferente do Matlab que a mantém em
tons de cinza. Para detecção de caracteres a binarização da imagem resultante é interessante
para eliminar os detalhes desnecessários da imagem.
Figura 28 – Aplicação da função de fechamento na imagem (i) resultando na imagem (ii), realizada no
Matlab.
Figura 29 – Aplicação da função de fechamento na imagem (i) resultando na imagem (ii), operação
realizada no Octave.
59
Esqueletonização: O objetivo da aplicação dessa função é a obtenção de uma
imagem resultante que exiba a linha de construção dos objetos na tela, especificamente as
linhas que compõem números na imagem. A imagem 30 exibe o resultado da aplicação da
esqueletonização em uma imagem binária. Observa-se que o algoritmo precisa de melhoria
para que o resultado final exiba apenas a linha fundamental de todos os componentes da
imagem original.
Figura 30 - Resultado (ii) da aplicação da função de esqueletonização na imagem (i) no Matlab.
Figura 31 – Resultado da aplicação de detecção de linhas horizontais (ii) e verticais (iii) na imagem (i) no
Octave.
60
Detecção de linhas: Para as funções de detecção de linhas é esperada uma imagem
de saída com as linhas destacadas de acordo com a função aplicada, 45º positivos, 45º
negativos, vertical ou horizontal. No caso de serem aplicadas a função linhas, as bordas da
imagem devem ser ressaltadas. As figuras 31 e 32 exibem os resultados da aplicação de
detecção de linhas verticais, horizontais, 45º positivos e negativos. A figura 33 mostra a
aplicação das quatro abordagens em uma imagem em tons de cinza.
Figura 32 – Resultado da aplicação de detecção de linhas 45º negativo (ii) e positivos (iii) na imagem (i) no
Octave.
Figura 33 – Resultado da aplicação de detecção de linhas (ii) na imagem (i) no Matlab.
61
Detecção de bordas: No caso desta função é esperada como saída uma imagem
cujas bordas dos objetos sejam evidenciadas. A figura 34 mostra o resultado da aplicação da
função de detecção de bordas em uma imagem.
Figura 34 – Resultado (ii) da aplicação do script de detecção de bordas na imagem (i). Executada no Matlab.
Segmentação: A função de segmentação codificada retorna a imagem com as
bordas dos caracteres evidenciadas. A figura 35 exibe a imagem de saída desta função.
Figura 35 – Resultado (ii) da aplicação da função de segmentação na imagem (i). Executada no Matlab.
62
De acordo com os resultados obtidos, pode-se definir que um fluxograma ideal
para as imagens da base de dados CBPF/MCT: aplicação da função de abertura na imagem,
para destacar a sequência numérica, em seguida aplicação da equalização. Nesta imagem
equalizada aplicar a segmentação e em seu resultado o fechamento, para evitar que as letras
fiquem com falhas. Por fim a aplicação da esqueletonização nessa imagem que está pronta
para a aplicação de algoritmo de reconhecimento de padrões.
Figura 36 – Fluxograma para imagens da base de dados CBPF/MCT.
O fluxograma definido na imagem 36 exibe o modo para o conjunto de imagens
com as características das imagens da base de dados CBPF/MCT. Esse conjunto de imagens
não possui ruídos que impeçam a aplicação das funções e possuem um nível de contraste bem
distribuído nos tons de cinza, não existindo imagens nem tão escuras nem tão claras que
atrapalhem a visualização da identificação da placa. Para um grupo de imagens genéricas foi
criado o fluxograma exibido na figura 37, que pode ser aplicado como uma lista de
verificações em uma base de imagens genérica. Seguindo o fluxo observa-se que situações em
que as imagens apresentem ruídos e contraste baixo são tratadas. Convém lembrar que em
63
situações de ruídos a aplicação de adição deverá ser utilizada conjuntamente com a média
dessas imagens.
Figura 37 – Fluxograma para imagens genéricas.
64
5. DOCUMENTAÇÃO
Este capítulo define as documentações utilizadas no desenvolvimento do
protótipo. O objetivo central do capítulo é nortear novos projetos a partir da documentação de
boas práticas observadas no projeto corrente.
Os tópicos que compõem o capítulo definem a documentação utilizada no
desenvolvimento do protótipo em si e na realização dos testes no protótipo.
5.1 Desenvolvimento do Protótipo
A documentação gerada no desenvolvimento do protótipo foi em forma de
comentários nos códigos e o presente projeto de pesquisa. Buscou-se deixar os comentários
nos códigos esclarecedores de modo a não poluir visualmente os scripts.
Para isso foi usado um padrão de documentação de cabeçalho com uma
identificação de onde aquele arquivo foi criado, o nome da faculdade e o semestre de
desenvolvimento, o nome da função do arquivo, uma breve descrição da função que o código
implementa, o nome do autor, a data de criação, as alterações e outras observações pertinentes
ao código. Esse cabeçalho é formatado com “%” no começo e fim de cada linha para que não
seja interpretado como implementação pelo compilador dos softwares. É posicionado na parte
superior de cada função.
65
Além do cabeçalho padrão no corpo da função são comentados os blocos de
comandos responsáveis por alocações de variáveis, criação de cópias da imagem de entrada,
implantação de funções adicionais e os comandos que compõem a rotina da função.
Comentários além destes somente foram adicionados quando o código implementado não era
de fácil entendimento, ou quando opções a implementação do código eram possíveis. O
padrão seguido para iniciar os arquivos de codificação está no Apêndice A – modelos de
formato dos arquivos fonte.
Durante a atividade de codificação nenhum outro documento foi criado, não
houve preocupação de se armazenar evidências de execução dos scripts nesta fase visto que o
período de testes era uma atividade já programada.
5.2 Realização dos Testes
Durante a realização dos testes foi utilizada uma planilha de controle de qualidade
do código, mencionada no tópico 4.2 do capítulo 4. Essa planilha teve importância tanto para
a atividade de codificação quanto para os testes. Sua utilização demonstrava os códigos que
necessitavam de retrabalho de codificação e quando o script atingia a qualidade desejada.
Entretanto não foi realizada com a planilha nenhum tipo de controle de versão,
visto que durante o desenvolvimento das funções esta necessidade não foi observada. A
utilização de um controle de versão permitiria coletar métricas como percentual de retrabalho
e incoerências recorrentes na codificação. Como esse fato viria adicionar uma carga extra de
atividades ao projeto sua implantação foi descartada, utilizando-se a planilha apenas para fins
de observação de quais funções ainda apresentavam defeitos.
Durante os testes, cada resultado considerado satisfatório produziu um grupo de
imagens de evidências. A armazenagem dessas imagens se deu através de criação de uma
árvore de diretórios, tornando desnecessária a utilização de ferramentas adicionais de
organização do banco de imagens. O mesmo processo foi adotado para as massas de teste. No
Apêndice B – modelos de planilha de controle de resultado dos testes, está documentado um
exemplo de planilha não preenchida.
66
Pode-se observar que a documentação gerada foi em quantidade mínima possível
objetivando facilitar a gerência desses artefatos. Além de evitar a absorção de atividades
desnecessárias ao projeto e uma consequente perda de produtividade.
67
6. CONCLUSÕES
A área de Processamento de Imagens apresenta uma gama de soluções para
diversos problemas cotidianos, entretanto suas soluções ainda não atingem o grau ótimo de
implementação. Dentre os fatores que colaboram para que este fato ocorra está a relação
intrínseca da área com a Matemática, a necessidade de construção de bases sólidas e extensas
de conhecimento para o domínio da matéria e a necessidade de recursos computacionais de
alto grau de desempenho para realização das tarefas.
Tais fatores contribuíram para que a área possua pouca permeabilidade de
profissionais. Essa falta de diversificação de pesquisas e de recursos humanos preparados
reflete o cenário atual da área, aplicações especializadas em domínios de aplicação restritos.
Visando chamar atenção para uma área que possui um alto índice de trabalhos publicados,
mas que ainda não atingiu um nível de maturidade adequado, este projeto foi proposto.
Inicialmente visto como a criação de um protótipo que sugerisse uma nova
abordagem para o reconhecimento de caracteres, o projeto desenvolveu-se como um possível
catalisador de novos pesquisadores. Agregando esta nova abordagem o projeto foi construído
com um foco principal além da construção de um protótipo, também como um modelo para
construção de protótipos ou aplicações utilizando softwares especializados de
desenvolvimento matemático. As ferramentas foram escolhidas levando em consideração que
sua aquisição fosse obtida de maneira simples e principalmente que a ferramenta
disponibilizasse uma base de ajuda, seja em forma de material ou de desenvolvedores, para
novos utilizadores. Procurou-se também utilizar tecnologias livres e confiáveis, e quando não
foi possível que a tecnologia fosse livre que esta possuísse um similar com tal característica.
68
O projeto inicialmente tinha um escopo de cobertura maior, era previsto a
construção de um protótipo que embarcaria características de reconhecimento de padrões.
Entretanto, no decorrer do desenvolvimento essa projeção teve que ser reavaliada, a
construção de um protótipo desse porte por um único pesquisador mantendo o caráter
pedagógico do projeto seria possível, porém com uma qualidade final comprometida. Devido
a essa reavaliação o projeto modificou o objetivo central para ser a construção das funções
que formariam os módulos de processamento básico e intermediário do protótipo inicial.
Ainda com o escopo reduzido pode-se observar as dificuldades em se
implementar protótipos sem utilizar bibliotecas proprietárias, ou ainda em uma linguagem
como o Matlab que possui pouco ou nenhuma implementação disponível para consulta,
apesar de apresentar uma melhora significativa na facilidade de implementação e
confiabilidade dos códigos, em comparação com a linguagem C# por exemplo.
Exemplificando a dificuldade de se desenvolver em linguagem como o Matlab, só foram
encontrados dois códigos que implementam esqueletonização, e ambos eram provenientes do
mesmo autor e estavam disponibilizados na página da MathWorks, enquanto na linguagem C
e C++ ou C# a oferta de códigos é farta. O problema identificado é que os códigos
apresentados em Matlab são extremamente direcionados para um tipo de imagem específica,
rachaduras que atravessem a imagem de extremidade a extremidade.Já nos códigos em outras
linguagens são utilizadas bibliotecas ou funções que impedem sua tradução imediata para a
linguagem Matlab ou ainda são escritos de forma incompreensível para desenvolvedores não
especializados na linguagem.
O código de esqueletonização mostrou-se como a mais difícil implementação. O
resultado final não é a versão ótima desse algoritmo, porém é uma abordagem que não utiliza
chamadas a funções complexas. Sua forma de implementação é simples e demonstra que é
possível a criação de funções sem a utilização de bibliotecas extensas ou módulos fechados.
Os outros algoritmos não se mostraram de difícil implementação, porém houve a necessidade
de reescrita dos códigos de modo a melhorar o entendimento do código globalmente.Com
esse processo a utilização de variáveis além do mínimo necessário pode ser adotada, fato que
não influi o desempenho do script.
A execução dos testes mostrou-se uma atividade de complexidade baixa, visto que
as ferramentas de codificação estão em versões estáveis e sem ocorrência de erros que
69
influenciem os resultados da execução dos códigos. A questão de lidar com ferramentas
instáveis era um risco assumido no início do projeto, visto que em experiências anteriores do
pesquisador as ferramentas demonstravam instabilidade durante o seu uso e utilização de
algumas de suas funções, em especial o Octave. Atualmente as versões se mostram além de
estáveis com uma otimização da utilização dos recursos disponibilizados pelo hardware,
memória e processador.
Outro aspecto que foi assumido como risco foi o método de exibição dos
resultados, as duas ferramentas utilizam motores de renderização e ferramentas de exibição
diferentes. Após a execução do primeiro teste o que se pode observar é que a qualidade das
imagens exibidas pelo Octave e seu mecanismo de exibição eram superiores aos do Matlab,
situação que se inverte quando se fala de gráficos de histograma, onde o Matlab exibe além
das coordenadas uma barra de dégradé de tons de cinza, que explicita ao usuário leigo qual o
extremo dos tons claros e escuros.
Por fim, observou-se que as divergências entre as implementações nas
ferramentas são mínimas. O reporte de erros de ambas as ferramentas é preciso e facilita o
processo de depuração do código. O método de trabalho das ferramentas é extremamente
simples e similar. Apesar da interface de utilização apontar para o Octave como um software
com limitações, essa impressão se desfaz durante a utilização.
A composição do referencial teórico encontrou um vasto material sobre os
assuntos a tratar. Observou-se que nos últimos anos os trabalhos na área de processamento de
imagens estão sendo direcionados para a área de Reconhecimento de Padrões, em especial
utilizando a área de Inteligência Artificial. A morfologia matemática é outro tópico comum
nesses trabalhos, e em outra vertente o reconhecimento de gestos, faces, digitais, objetos, etc.
Esse cenário reflete um caminho da área para a aplicação em soluções que sejam utilizadas
pelo usuário final, diferente das aplicações que até a década de 90 eram prioritárias, como o
uso militar e médico. O desenvolvimento de celulares e outros gadgets com uma capacidade
de processamento cada vez maior expandem as possibilidades de utilização da área de
Processamento de Imagens.
Finalmente, a conclusão que se chega é que o desenvolvimento de um projeto na
área de Processamento de Imagens demanda tempo e requer uma preparação prévia. Para que
70
um projeto venha a ser desenvolvido nessa área com sucesso é necessário um planejamento
prévio, objetivos claros e uma gerência forte. Não é realmente necessário o desenvolvimento
de funções básicas, existem inúmeras bibliotecas que suprem essa necessidade, entretanto o
período reservado para análise, codificação e testes dessas funções é fundamental para
eliminação de falhas de entendimento, fator que é relevante para construção de códigos mais
elaborados com maior exatidão. A metodologia seguida neste projeto não se apoiou em
nenhum modelo de desenvolvimento devido a equipe reduzida, este ponto deve ser analisado
em casos de projetos com maior número de integrantes. Outro fator de sucesso do projeto foi
o período reservado para o estudo do referencial teórico, que possibilitou no período de
codificação a adoção de alternativas mais eficazes para os problemas apresentados.
O projeto em sua versão final atingiu todos os objetivos propostos, desde sua
visão pedagógica sobre a área até a disponibilização de códigos e métodos, além da
experiência documentada para servir de insumo para novos projetos. A contribuição deste
trabalho é fornecer mais um “ponto de luz” nas questões que ainda não possuem uma solução
ótima. É com esta visão de novas contribuições que o projeto é concluído, esperando que
estes pontos que não apresentam cobertura adequada sejam vistos e tratados e que novos
ingressantes na área vejam o Processamento de Imagens para além da disciplina cursada, mas
como um ramo de estudo.
71
7. TRABALHOS FUTUROS
A partir dos resultados obtidos com o trabalho presente sugere-se como novos
projetos, a implementação do módulo de processamento avançado do protótipo, com
implementação da interface. A melhoria do algoritmo de esqueletonização de modo que possa
atender a uma gama maior de imagens. Migração do protótipo pronto para uma plataforma
Linux.
Seguindo a idéia do protótipo pronto, agregar funcionalidades que estão em
evidência atualmente, mas que não cobrem o escopo da área. Sugere-se a existência de uma
notificação do infrator logo após a aplicação da multa. Com o protótipo atendendo índices de
identificação satisfatórios, logo após a identificação da placa, automaticamente um outro
sistema iniciaria o processo de envio de mensagem para o telefone cadastrado no órgão
responsável, seja uma gravação prévia ou uma mensagem de texto em caso de celulares e um
sistema web para conferência de dados.
Em aplicações na área de Processamento de Imagens, estudos sobre a
identificação de gestos a partir do uso da esqueletonização, principalmente para celulares e
aparelhos com tela sensível ao toque. Ressaltando que um estudo conjunto de otimização de
aplicações que processam imagens nos softwares e hardware desses aparelhos seria
conveniente.
Em aplicações que estejam focadas no Reconhecimento de Padrões uma
funcionalidade em evidência atualmente é a identificação de rostos de pessoas em imagens,
estendendo esse conceito a identificação de sorrisos, tipos de roupas, adereços, cores, objetos,
72
juntamente com a associação a uma identificação à imagem são exemplos de aplicações que
possuem grande procura no mercado.
É notável como o domínio de aplicação da área está amplo, com a oferta cada vez
maior de banda larga, a popularização da internet e do hardware, a otimização e barateamento
de itens de hardware, condições propícias no comércio e massificação da web 2.0, das redes
sociais e da multimídia na internet, o cenário atual aponta para aplicações que atendam nichos
de mercado.
Ferramentas complexas que executam várias funções estão sendo migradas pelo
usuário comum para ferramentas que executem poucas tarefas que atendam as suas
necessidades. Esse novo comportamento deve ser observado de perto e deve-se estar atento
para as oportunidades que essa ação apresenta. Como dito durante o trabalho, as aplicações de
processamento de imagens ainda não atendem a necessidade, explorar as falhas atuais
oferecendo propostas simples são fatores que apontam para o sucesso dos projetos.
73
REFERÊNCIAS BIBLIOGRÁFICAS
ALBUQUERQUE, Márcio Portes de; ALBUQUERQUE , Marcelo Portes de. Processamento
de imagens: Métodos e Análises. 2000. 12 f. Centro Brasileiro de Pesquisas Físicas,
CBPF/MCT, Rio de Janeiro, 2000. Disponível em
<www.cbpf.br/cat/pdsi/pdf/ProcessamentoImagens.PDF> Acesso em 8 de jun de 2009.
BONFIGLIOLI, Cristina Pontes. Representação e pensamento: a visibilidade dependente. 2008. 9 f. Trabalho apresentado ao Grupo de Trabalho do XVII Encontro da Compós, Universidade Paulistana, UNIP, São Paulo, 2008. Disponível em < http://www.compos.org.br/data/biblioteca_296.pdf> Acesso em 19 abr. 2009.
BRASIL. Lei nº 9.503, de 23 de setembro de 1997. Código de Trânsito Brasileiro. Disponível em < http://rootis.com/Opiniao/Lei9503CodigodeTransitoBrasileiro.html > Acesso em 19 abr. 2009.
CARVALHO, Bernardo P. R. O estado da arte em métodos para reconhecimento de padrões: Support Vector Machine. Belo Horizonte-MG: SUCESU 2005 - Congresso Nacional de Tecnologia da Informação e Comunicação, 2005.
CBPF - Centro Brasileiro de Pesquisas Físicas. Matlab. Curso Introdutório. Rio de Janeiro, 2002. Disponível em < http://mesonpi.cat.cbpf.br/e2002/cursos/NotasAula/Tutorial_matlab.pdf > Acesso em 25 de ago. 2009.
CONCI, Aura; AZEVEDO, Eduardo; LETA, Fabiana. Computação gráfica volume 2: Processamento de Imagens Teoria e Prática . Rio de Janeiro: Campus/Elsevier, 2008.
DIVALTE, Garcia F. História. São Paulo: Editora Ática, 2000.
DOUGHERTY, Edward R.; LOTUFO, Roberto A. Hands-on morphological image processing. Washington: SPIE PRESS, 2003.
74
FELGUEIRAS, Carlos Alberto. Processamento digital de imagens. 2007. Notas de aula. Disponível em <http://www.dpi.inpe.br/~carlos/Academicos/Cursos/Pdi/pdi_filtros.htm> Acesso em 27 mai 2009.
FONSECA, Leila Maria Garcia. Processamento digital de imagens. 2000. 105 f. Notas de aula. Disponível em <http://geosere.ccr.ufsm.br//files> Acesso em 12 abr. 2009.
GONZALEZ, Rafael C.; WOODS, Richard E. Processamento de imagens digitais. São Paulo: Edgard Blucher, 2000.
LEITE, Neucimar J. Introdução ao processamento de imagens digitais. Campinas: Instituto de Computação - Unicamp, 2004. Disponível em <http://www.ic.unicamp.br/~afalcao/sensremoto/processamento.ppt> Acesso em 25 mai. 2009.
MATHWORKS. Documentation: Matlab. 2009. Disponível em <
http://www.mathworks.com/access/helpdesk/help/techdoc/index.html> Acesso em 08 ago. 2009.
MICHAELIS. Moderno dicionário da língua portuguesa. Rio de Janeiro: Reader’s Digest; São Paulo: Melhoramentos, 2000. 2 v.
NEVES, Samuel C. M.; PELAES, Evaldo. G. Estudo e implementação de técnicas de segmentação de imagens. Revista Científica da UFPA, Belém, v.1, n. 2, jul. 2001.
NEVES, Sérgio R.; Algoritmos para segmentação de imagens infravermelhas. Rio de Janeiro, 2003. Disponível em < http://www.pee.ufrj.br/teses/?Resumo=2003061251> Acesso em 01 ago. 2009.
PREFEITURA DE FORTALEZA. Autarquia Municipal de Trânsito. AMC : Menos pedestres mortos em acidentes de trânsito. Fortaleza, 2007. Disponível em < http://www.amc.fortaleza.ce.gov.br/modules/news/article.php?storyid=2818> Acesso em 19 abr. 2009.
75
OCTAVE. Octave Documentation. 2009. Disponível em <
http://www.gnu.org/software/octave/docs.html > Acesso em 14 ago. 2009.
RAJAN , Jeny, CHANDRASEKHAR P.S. Matlab Code, 2006. Disponível em <
http://www.mathworks.com/matlabcentral/fileexchange/8031> Acesso em 25 out. 2009.
SCALON, Vicente Luiz. Introdução aos Sistemas Matlab/GNU Octave. São Paulo, 2008. Disponível em <http://wwwp.feb.unesp.br/scalon/grad> Acesso em 14 nov. 2009
SCURI, Antonio Escaño. Fundamentos da imagem digital. Rio de Janeiro, 2002. Disponível em <http://www.tecgraf.puc-rio.br/~scuri/download/fid.pdf > Acesso em 27 fev. 2009.
SEARA, Daniela Marta. Algoritmos para detecção de bordas. Florianópolis, 1998. Disponível em < http://www.inf.ufsc.br/~visao/1998/seara/> Acesso em 25 mai. 2009.
SUN. Software MySQL: Visão geral. 2009. Disponível em <
http://br.sun.com/practice/software/mysql/> Acesso em 14 ago. 2009.
TAGLIAFERRO, Fátima Aparecida. Técnicas de reconhecimento automatizado de padrões baseados em imagens digitais. 2007. 44 f. Trabalho de Conclusão de Curso (Ciência da Computação) Faculdade de Jaguariúna, FAJ, Jaguariúna, 2007. Disponível em < http://bibdig.faj.br/document/?view=65> Acesso em 02 mar. 2009.
76
MATERIAL DE ESTUDO
ADVANCED SOURCE CODE. Interfacing Matlab to MySQL. 2007. Disponível em <
http://www.advancedsourcecode.com/matlabphpmysql.asp> Acesso em 12 out. 2009.
GONZALEZ, Rafael C.; WOODS, Richard E.; EDDINS, Steven L. Digital image processing using MATLAB. Pearson Prentice Hall, 2004.
HAHN, Brian; VALENTINE, Daniel T. Essential Matlab® for engineers and scientists: Third Edition. 3 ed. Burlington: Elsevier, 2007.
KUNCICKY, David C. MATLAB® programming. Englewood Clifs, N.J.: Prentice Hall, 2003.
MITRA, Sanjit, K. Digital signal processing: A computer-based approach. 2 ed. New York: McGrawHill, 2003.
MYLER, Harley R.; WEEKS, Arthur R. The pocket handbook of image processing algorithms in C. Englewood Clifs, N.J.: Prentice Hall, 2006.
PARKER, J. R. Algorithms for image processing and computer vision. New York: John Wiley & Sons, 1997.
PRATT, William K. Digital image processing . 4 ed. Hoboken, N. J.: Wiley-Interscience, 2007.
SALERI, Fausto; QUARTERONI, Alfio. Scientific computing with Matlab® and Octave. 2 ed. Berlin: Springer-Verlag, 2006.
77
VIEIRA, Danilo R. Criando uma interface gráfica para obter distâncias entre pontos em uma figura. 2009. Disponível em < http://alunoca.io.usp.br/~drvieira/matlab/gui-ptos/> Acesso em 12 out. 2009.
78
APÊNDICE A – MODELOS DE FORMATO DOS ARQUIVOS FONTE
%-------------------------------------------------------------------------% % Código Utilizado no Protótipo desenvolvido durante o % % Projeto de TCC II % % Faculdade Farias Brito % % 2009.2 % % Função : % % Descrição : % % Autor : Vinicius Lima % % Data : // % % Alterações: % %-------------------------------------------------------------------------% function nome_da_funcao(parametros) %definição das variáveis de apoio e %criação de imagens auxiliares de mesmo tamanho % rotina da função endfunction
79
APÊNDICE B – MODELOS DE PLANILHA DE CONTROLE DE RESULTADO DOS
TESTES
Identificação
Nome do código-fonte
Data Identificação Comentários-erro
Comentários-correção
80
APÊNDICE C – CÓDIGOS DA IMPLEMENTAÇÃO
Função: Abertura
function abertura(imagem1) %definição das variáveis de apoio e %criação de imagens auxiliares de mesmo tamanho Ver_ima = imread(imagem1); [lin,col,dim] = size(Ver_ima); copia_01 = Ver_ima; copia_02 = zeros(lin,col); copia_03 = zeros(lin,col); % definição do elemento estruturante % arbitrary - elementos produzidos pelo desenvolvedor % square - quadrados, somente fornecido o tamanho % rectangule - retangulos, fornecido quantidade de linhas e colunas da matriz. ee_ab = strel('arbitrary',[0 0 0; 1 1 1; 0 1 0]); %ee_ab = strel('square',3); %ee_ab = strel('rectangle',[2 1]); %Para o Octave comentar as linhas acima que usam ‘Strel’ e descomentar a linha seguinte %ee_ab = [0 0 0; 1 1 1; 0 1 0]; % rotina da função copia_02 = imerode(copia_01,ee_ab); copia_03 = imdilate(copia_02,ee_ab); imshow(copia_03,[]); endfunction
Função: Adição
function adicao(imagem1, imagem2) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_im1 = imread(imagem1); copia_im2 = imread(imagem2); [lin1,col1] = size(copia_im1); [lin2,col2] = size(copia_im2);
81
% verificação dos tamanhos da imagens if(lin1 ~= lin2 || col1 ~= col2) printf('Imagens de tamanhos diferentes'); end mat_imag = copia_im1; mat_imag2 = copia_im2; mat_final = zeros(lin1,col1); % rotina for i = 1:lin1 for j = 1:col1 aux = mat_imag(i,j) + mat_imag2(i,j); if(aux < 0) aux = 0; end if(aux > 255) aux = 255; end mat_final(i,j) = aux; end end imshow(mat_final); endfunction
Função: Borda
Baseado no algoritmo de Jeny Rajan e Chandrashekar
function borda(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tamanho Ver_tam = imread(imagem); copia_01 = Ver_tam; % Aplicação do filtro mediana para remover possíveis ruídos na imagem % Analisar a necessidade copia_01 = medfilt2(copia_01,[3 3]); % Função inerente do Matlab para identificação de bordas copia_bordas = edge(copia_01,'sobel'); imshow(copia_bordas,[]); endfunction
82
Função: Equalização
function equaliza(imagem1) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem1); % Rotina h = histeq(copia_01); figure, imhist(h); figure, histeq(copia_01) endfunction
Função: Esqueletonização
function esqueleto(imagem1) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tamanho Ver_ima = imread(imagem1); [lin,col,dim] = size(Ver_ima); copia_01 = Ver_ima; copia_02 = zeros(lin,col); copia_hit = zeros(lin,col); nulo = 0; aux1 = 0; aux2 = 0; ee = [1 1 1; 0 1 0; 0 0 0]; ee1 = [0 0 0; 0 1 0; 1 1 1]; ee2 = [0 0 0; 0 1 0; 0 1 0]; %criar o inverso da imagem original for i=1:lin for j=1:col if(copia_01(i, j)== 0) copia_02(i, j) = 1; else copia_02(i, j) = 0; end end end
83
%%%%%%%%%%%%%% ITERAÇÃO 01 %%%%%%%%%%%%%%%%%%% nulo = 0; % definição dos elementos estruturantes e seu inverso 01 ee_ab01 = [0 1 1; 0 1 1; 0 1 1]; while(nulo == 0) nulo = 0; % criar as imagens erodidas ima_ero01 = imerode(copia_01, ee_ab01); %realizar a operação de hitormiss na imagem for i=1:lin for j=1:col if(ima_ero01(i, j) == 1) copia_hit(i, j) = 1; end end end %criar o inverso da imagem hit for i=1:lin for j=1:col if(copia_hit(i, j)== 0) copia_hit(i, j) = 1; else copia_hit(i, j) = 0; end end end % rotina de afinamento [lin, col] = size(copia_01); for i=1:lin for j=1:col if(copia_01(i, j) == copia_hit(i, j)) copia_01(i, j) = 1; else copia_01(i, j) = 0; end end end % definição do ponto de parada for i=1:lin for j=1:col if(copia_01(i, j) == Ver_ima(i, j)) nulo = 0;
84
else nulo = 1; end end end end %endwhile %%%%%%%%%%%%%% ----------- %%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%% ITERAÇÃO 02 %%%%%%%%%%%%%%%%%%% nulo = 0; % definição dos elementos estruturantes e seu inverso 02 ee_ab02 = [0 0 0; 1 1 1; 1 1 1]; while(nulo == 0) nulo = 0; % criar as imagens erodidas ima_ero02 = imerode(copia_01, ee_ab02); %realizar a operação de hitormiss na imagem for i=1:lin for j=1:col if(ima_ero02(i, j) == 1) copia_hit(i, j) = 1; end end end %criar o inverso da imagem hit for i=1:lin for j=1:col if(copia_hit(i, j)== 0) copia_hit(i, j) = 1; else copia_hit(i, j) = 0; end end end % rotina de afinamento [lin, col] = size(copia_01); for i=1:lin for j=1:col if(copia_01(i, j) == copia_hit(i, j)) copia_01(i, j) = 1; else copia_01(i, j) = 0; end
85
end end % definição do ponto de parada for i=1:lin for j=1:col if(copia_01(i, j) == Ver_ima(i, j)) nulo = 0; else nulo = 1; end end end end %endwhile %%%%%%%%%%%%%% ----------- %%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%% ITERAÇÃO 03 %%%%%%%%%%%%%%%%%%% nulo = 0; % definição dos elementos estruturantes e seu inverso 03 ee_ab03 = [1 0 0; 1 1 0; 1 0 0]; while(nulo == 0) nulo = 0; % criar as imagens erodidas ima_ero03 = imerode(copia_01, ee_ab03); %realizar a operação de hitormiss na imagem for i=1:lin for j=1:col if(ima_ero03(i, j) == 1) copia_hit(i, j) = 1; end end end %criar o inverso da imagem hit for i=1:lin for j=1:col if(copia_hit(i, j)== 0) copia_hit(i, j) = 1; else copia_hit(i, j) = 0; end end end % rotina de afinamento [lin, col] = size(copia_01);
86
for i=1:lin for j=1:col if(copia_01(i, j) == copia_hit(i, j)) copia_01(i, j) = 1; else copia_01(i, j) = 0; end end end % definição do ponto de parada for i=1:lin for j=1:col if(copia_01(i, j) == Ver_ima(i, j)) nulo = 0; else nulo = 1; end end end end %endwhile %%%%%%%%%%%%%% ----------- %%%%%%%%%%%%%%%%%%% copia_hit = imerode(copia_hit,ee); copia_hit = imerode(copia_hit,ee2); % copia_hit = imerode(copia_hit,ee2); copia_hit = imdilate(copia_hit,ee2); imshow(copia_hit,[]); end
Função: Fechamento
function fechamento(imagem1) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tamanho Ver_ima = imread(imagem1); [lin,col,dim] = size(Ver_ima); copia_01 = Ver_ima; copia_02 = zeros(lin,col); copia_03 = zeros(lin,col);
87
% definição do elemento estruturante % arbitrary - elementos produzidos pelo desenvolvedor % square - quadrados, somente fornecido o tamanho % rectangule - retangulos, fornecido quantidade de linhas e colunas da matriz. ee_ab = strel('arbitrary',[0 0 0; 1 1 1; 0 1 0]); %ee_ab = strel('square',3); %ee_ab = strel('rectangle',[2 1]); %Para o Octave comentar as linhas acima que usam ‘Strel’ e descomentar a linha seguinte %ee_ab = [0 0 0; 1 1 1; 0 1 0]; % rotina da função copia_02 = imdilate(copia_01,ee_ab); copia_03 = imerode(copia_02,ee_ab); imshow(copia_03,[]); endfunction
Função: Histograma
function histograma(imagem1) % leitura da imagem copia_01 = imread(imagem1); % rotina figure, imhist(copia_01) endfunction
Função: Detecção de Linhas 45º negativos
function linhas45n(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem); [lin,col] = size(copia_01); copia_02 = zeros(lin,col); masca = [-1 -1 2; -1 2 -1; 2 -1 -1]; % rotina da função copia_02 = conv2(copia_01, masca);
88
imshow(copia_02); endfunction
Função: Detecção de Linhas 45º positivos
function linhas45n(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem); [lin,col] = size(copia_01); copia_02 = zeros(lin,col); masca = [2 -1 -1; -1 2 -1; -1 -1 2]; % rotina da função copia_02 = conv2(copia_01, masca); imshow(copia_02); endfunction
Função: Detecção de Linhas horizontais
function linhash(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem); [lin,col] = size(copia_01); copia_02 = zeros(lin,col); masca = [-1 -1 -1; 2 2 2; -1 -1 -1]; % rotina da função copia_02 = conv2(copia_01, masca); imshow(copia_02); endfunction
89
Função: Detecção de Linhas verticais
function linhasv(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem); [lin,col] = size(copia_01); copia_02 = zeros(lin,col); masca = [-1 2 -1; -1 2 -1; -1 2 -1]; % rotina da função copia_02 = conv2(copia_01, masca); imshow(copia_02); endfunction
Função: Detecção de Linhas
function linhas(imagem) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_01 = imread(imagem); [lin,col] = size(copia_01); copia_02 = zeros(lin,col); copia_03 = zeros(lin,col); copia_04 = zeros(lin,col); copia_05 = zeros(lin,col); copia_06 = zeros(lin,col); mascav = [-1 2 -1; -1 2 -1; -1 2 -1]; mascah = [-1 -1 -1; 2 2 2; -1 -1 -1]; mascap = [ 2 -1 -1; -1 2 -1; -1 -1 2]; mascan = [-1 -1 2;
90
-1 2 -1; 2 -1 -1]; % rotina da função copia_02 = conv2(copia_01, mascav); copia_03 = conv2(copia_01, mascah); copia_04 = conv2(copia_01, mascap); copia_05 = conv2(copia_01, mascan); copia_06 = copia_02 + copia_03 + copia_04 + copia_05; imshow(copia_06); endfunction
Função:Segmentação
Baseado no algoritmo de Jeny Rajan e Chandrashekar
function seg(imagem1) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tamanho Ver_ima = imread(imagem1); [lin,col,dim] = size(Ver_ima); copia_01 = Ver_ima; copia_02 = zeros(lin,col); %Aplicação do filtro mediana para eliminar ruído copia_01 = medfilt2(copia_01,[3 3]); %Aplicação de função para encontrar bordas copia_02 = edge(copia_01,'sobel'); [lin02,col02]=size(copia_02); masca = [0 0 0 0 0; 0 1 1 1 0; 0 1 1 1 0; 0 1 1 1 0; 0 0 0 0 0;]; %Suavização - diminui os objetos conectados na imagem ima_su = conv2(double(copia_02),double(masca)); %Calculo dos componentes conectados ima_con = bwlabel(ima_su,8);
91
maxi = max(max(ima_con)); %armanazenar a imagem num vetor [r,c] = find(ima_con == 17); rc = [r c]; [sx sy] = size(rc); n1 = zeros(lin02,col02); for i=1:sx x1 = rc(i,1); y1 = rc(i,2); n1(x1,y1)=255; end %imshow(Ver_ima); %imshow(copia_01); imshow(ima_su); %imshow(n1,[]); end
Função:Subtração
function subtra(imagem1, imagem2) % definição das variáveis de apoio e % criação de imagens auxiliares de mesmo tam. copia_im1 = imread(imagem1); copia_im2 = imread(imagem2); [lin1,col1] = size(copia_im1); [lin2,col2] = size(copia_im2); % verificação dos tamanhos da imagens if(lin1 ~= lin2 || col1 ~= col2) printf('Imagens de tamanhos diferentes'); end mat_imag = copia_im1; mat_imag2 = copia_im2; mat_final = zeros(lin1,col1); % rotina for i = 1:lin1 for j = 1:col1 aux = mat_imag(i,j) - mat_imag2(i,j); if(aux < 0) aux = 0; end
92
if(aux > 255) aux = 255; end mat_final(i,j) = aux; end end imshow(mat_final); endfunction
93
APÊNDICE D – MASSA DE TESTES
Grupo de Imagens Básicas
Arquivo: “conso.jpg” – 490x224
Arquivo: “Consoantes.png” – 150x113
Arquivo: “cup.png” – 100x100
Arquivo: “flower.png” – 100x100
94
Arquivo: “gear.png” – 100x100
Arquivo: “letras.jpg” – 490x224
Arquivo: “letras2.jpg” – 490x224
Arquivo: “Letras.png” – 160x121
95
Arquivo: “LetrasLinhas.png” – 200x151
Arquivo: “LetrasNumeros.png” – 200x151
Arquivo: “LetrasNumerosLinhas.png” – 200x151
Arquivo: “Linhas45n.png” – 160x121
96
Arquivo: “Linhas45p.png” – 160x121
Arquivo: “Linhas.png” – 160x121
Arquivo: “LinhasH.png” – 160x121
Arquivo: “LinhasV.png” – 160x121
Arquivo: “number.png” – 110x68
97
Arquivo: “Numeros.png” – 150x113
Arquivo: “NumerosLinhas.png” – 150x113
Arquivo: “vogais.jpg” – 490x224
Arquivo: “Vogais.png” – 120x90
98
Grupo de Imagens de Calibração
Arquivo: “01.png” – 150x113
Arquivo: “02.png” – 150x113
Arquivo: “03.png” – 150x113
Arquivo: “64bits.jpg” – 500x333
99
Arquivo: “car3.jpg” – 436x302
Arquivo: “SA_Brazil_GI.jpg” – 544x464
Grupo de Imagens da Base
Arquivo: “Base (01).jpg” – 640x240
100
Arquivo: “Base (2).jpg” – 640x240
Arquivo: “Base (3).jpg” – 640x240
Arquivo: “Base (4).jpg” – 640x240
Arquivo: “Base (5).jpg” – 640x240
101
Arquivo: “Base (6).jpg” – 640x240
Arquivo: “Base (7).jpg” – 640x240
Arquivo: “Base (8).jpg” – 640x240
Arquivo: “Base (9).jpg” – 640x240
102
Arquivo: “Base (10).jpg” – 640x240
Arquivo: “Base (11).jpg” – 640x240
Arquivo: “Base (12).jpg” – 640x240
Arquivo: “Base (13).jpg” – 640x240
103
Arquivo: “Base (14).jpg” – 640x240
Arquivo: “Base (15).jpg” – 640x240
Arquivo: “Base (16).jpg” – 640x240
Arquivo: “Base (17).jpg” – 640x240
104
Arquivo: “Base (18).jpg” – 640x240
Arquivo: “Base (19).jpg” – 640x240
Arquivo: “Base (20).jpg” – 640x240
105
ANEXO I - CONSTRUÇÃO DA INTERFACE
Tutorial desenvolvido por Danilo Vieira e disponibilizado em
<http://alunoca.io.usp.br/~drvieira/matlab/gui-ptos/>>, a versão aqui documenta foi editada.
Criando a interface
Executar a função guide no prompt do Matlab. Esta função trará a janela exibida na
figura Anexo I -.1:
Anexo I - 1: janela exibida ao solicitor a função guide.
Seleciona-se uma das opções de templates, automaticamente será criado um arquivo
*.m correspondente à sua interface. Este arquivo conterá o código para as ações dos botões,
controles de texto, menus e demais componentes existentes na interface.
Na tela seguinte a interface é construída a partir da ação de arrastar e soltar os
elementos. A figura Anexo I - 2 exibe essa situação. Após o salvamento da interface, esta é
salva com o nome fornecido, seu comportamento é parecido com uma função normal.
106
Anexo I - 2 – Exemplo de construção de uma interface.
Codificando o exemplo
“Para associar ações aos componententes, o Matlab utiliza os chamados callbacks”
% --- Executes on button press in pushbutton1. function pushbutton1_Callback(hObject, eventdata, handles) % hObject handle to pushbutton1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % mostra uma tela para que o usuário escolha um arquivo de imagem: [filename, canceled] = imgetfile; % se o usuário não tiver cancelado if ˜canceled % guarda o nome do arquivo handles.arquivo = filename; % abre a imagem handles.imagem = imread(filename); % seleciona o componente axes1 axes(handles.axes1); % exibe a figura imshow(handles.imagem); end % reseta a referência handles.px2min = NaN; % salva a variável handles guidata(hObject, handles);
107
“Handles são números que identificam os componentes, eles ficam armazenados na
variável handles. Essa variável é do tipo struct e é muito importante: é a única que está
disponível para todos os callbacks, pois é salva com a função guidata.”
% --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) % hObject handle to pushbutton3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % ativa o axes1 axes(handles.axes1); % mostra a imagem (isso reseta a imagem quando marcamos uma nova referência) imshow(handles.imagem); % pegamos qual a distância que o usuário que marcou % ("edtRef" é a propriedade "Tag" da caixa de texto) numRef = str2double(get(handles.edtRef, 'String')); % Vê se o usuário digitou um número válido, caso contrário % mostra uma mensagem e sai desse callback if isnan(numRef) || (numRef <= 0) % mostra a mensagem errordlg('Por favor, digite um número válido.', 'Erro'); % sai da função return; end % pede para o usuário marcar dois pontos ptos = ginput(2); % calcula a distância em pixels que o usuário marcou. % se você estudou vetores, sabe que distância entre pontos % pode ser obtida pela norma do vetor que tem % início num ponto e fim no outro, então basta chamar % a função norm com a diferença entre os pontos como % parâmetro. c = norm(ptos(1,:)-ptos(2,:)) / numRef; % converte a distância em pixels para milhas náuticas, levando % em consideração que o usuário pode ter marcado em qualquer % unidade disponível. % get(handles.popupmenu1, 'Value') retorna qual item o usuário escolheu switch get(handles.popupmenu1, 'Value') case 1 % minuto fator = c; case 2 % segundo fator = c / (1/60); case 3 % grau fator = c / 60; case 4 % quilometro fator = c / (1/(1852 * 1000)); case 5 % metro fator = c / (1/1852); end
108
% guarda a referência handles.px2min = fator; guidata(hObject, handles);
% --- Executes on button press in pushbutton2. function pushbutton2_Callback(hObject, eventdata, handles) % hObject handle to pushbutton2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) if isnan(handles.px2min) errordlg('Marque a referência primeiro', 'Erro'); return; end numEst = str2double(get(handles.edtNumEst, 'String')); if ~isnan(numEst) && numEst > 1 axes(handles.axes1); pto = ginput(1); hold on; plot(pto(1), pto(2), 'xr'); else errordlg('Por favor, digite um número válido de estações.', 'Erro'); return; end for j=2:numEst last = pto; pto = ginput(1); plot(pto(1), pto(2), 'xr'); line([last(1) pto(1)], [last(2) pto(2)]); d = ( norm(last-pto) / handles.px2min ) * 1852; text(pto(1)+(last(1)-pto(1))/2, pto(2)+(last(2)-pto(2))/2, ... sprintf('%.2fm', d), 'backgroundcolor', 'y'); end hold off;
Transformando num executável
Para transformar a interface num programa portável:
mcc -m interface.m
Será necessária a instalação do MCR (MATLAB Compiler Runtime) um compilador
que é livre e não necessita de compra.
109
ANEXO II - CONEXÃO COM O BANCO
Scripts de conexão disponibilizados pela Advanced Source Code e podem ser
encontrados em (http://www.advancedsourcecode.com/matlabphpmysql.asp)
Entrada de dados - MySql:
function [out]=mysql_input(hostname,username,password,query,url) % [out]=mysql_input(hostname,username,password,query,url) % This function executes a list of MySql commands where no output is % required (for example INSERT, UPDATE, ...). % INPUT: % hostname: 'localhost' or the host name string % username: MySql username % password: MySql password % query: the list with MySql commands. Query is a cell. % url: the URL of the .php file that is used to interface with MySql % server % OUTPUT: % out: always set to 1 % Query escape string L = length(query); for ii=1:L q = query{ii}; q = strrep(q, ' ', '_spazio_'); % ASCII code 32 q = strrep(q, '''', '_apice_'); % ASCII code 39 q = strrep(q, '\', '_slash_'); % ASCII code 92 q = strrep(q, '"', '_virgo_'); % ASCII code 34 q = strrep(q, '#', '_canc_'); % ASCII code 35 q = strrep(q, '%', '_perc_'); % ASCII code 37 q = strrep(q, '&', '_and_'); % ASCII code 38 query{ii} = q; end % Set POST parameters opt{1} = 'hostname'; opt{2} = hostname; opt{3} = 'username'; opt{4} = username; opt{5} = 'password'; opt{6} = password; L = length(query); myquery = query{1}; for ii=2:L myquery = strcat(myquery,'_pck_',query{ii}); end opt{7} = 'myquery'; opt{8} = myquery; % Retry to read the URL done = 0; while done==0
110
try % Try to read the URL HTML = urlread(url,'POST',opt); done = 1; catch % If an error has occurred wait for some time before re-trying disp('Error during URL reading. Retrying...'); done = 0; pause(0.2); end end out = 1;
Saída de dados - MySql:
function [out]=mysql_output(hostname,username,password,query,url) % [out]=mysql_output(hostname,username,password,query,url) % This function executes a list of MySql commands where some output is % required (just like a SELECT command). % The list of MySql commands can include several commands where the last % one can be a SELECT command (the output of the function). % INPUT: % hostname: 'localhost' or the host name string % username: MySql username % password: MySql password % query: the list with MySql commands. Query is a cell. % url: the URL of the .php file that is used to interface with MySql % server % OUTPUT: % out: a cell with the results. % Query escape string L = length(query); for ii=1:L q = query{ii}; q = strrep(q, ' ', '_spazio_'); % ASCII code 32 q = strrep(q, '''', '_apice_'); % ASCII code 39 q = strrep(q, '\', '_slash_'); % ASCII code 92 q = strrep(q, '"', '_virgo_'); % ASCII code 34 q = strrep(q, '#', '_canc_'); % ASCII code 35 q = strrep(q, '%', '_perc_'); % ASCII code 37 q = strrep(q, '&', '_and_'); % ASCII code 38 query{ii} = q; end % Set POST parameters opt{1} = 'hostname'; opt{2} = hostname; opt{3} = 'username'; opt{4} = username; opt{5} = 'password'; opt{6} = password; L = length(query); myquery = query{1};
111
for ii=2:L myquery = strcat(myquery,'_pck_',query{ii}); end opt{7} = 'myquery'; opt{8} = myquery; % Retry to read the URL done = 0; while done==0 try % Try to read the URL HTML = urlread(url,'POST',opt); done = 1; catch % If an error has occurred wait for some time before re-trying disp('Error during URL reading. Retrying...'); done = 0; pause(0.2); end end HTMLnum = double(uint8(HTML)); pos = find(HTMLnum == 10); L = length(pos); cont = 1; p0 = 1; for ii=1:L p1 = pos(ii)-1; stringa = HTML(p0:p1); if ~(length(stringa)==1 && double(uint8(stringa))==10) out{cont} = stringa; cont = cont+1; end p0 = p1+1; end
Entrada de dados - PHP:
<?php $link = mysql_connect('$hostname','$username','$password'); $explode_result = explode("_pck_",$myquery); $L = count($explode_result); for ($ii=0;$ii<$L;$ii=$ii+1) { $query = $explode_result[$ii]; $query = str_replace("_apice_","'",$query); $query = str_replace("_spazio_"," ",$query); $query = str_replace("_slash_","\\",$query); $query = str_replace("_virgo_","\"",$query); $query = str_replace("_canc_","#",$query); $query = str_replace("_perc_","\%",$query); $query = str_replace("_and_","&",$query); $risultato = mysql_query($query); } ?>
112
Saída de dados - PHP:
<?php $link = mysql_connect('$hostname','$username','$password'); $explode_result = explode("_pck_",$myquery); $L = count($explode_result); for ($ii=0;$ii<$L;$ii=$ii+1) { $query = $explode_result[$ii]; $query = str_replace("_apice_","'",$query); $query = str_replace("_spazio_"," ",$query); $query = str_replace("_slash_","\\",$query); $query = str_replace("_virgo_","\"",$query); $query = str_replace("_canc_","#",$query); $query = str_replace("_perc_","\%",$query); $query = str_replace("_and_","&",$query); $risultato = mysql_query($query); } while ($riga = mysql_fetch_array($risultato)) { $L = count($riga); for ($ii=0;$ii<$L;$ii=$ii+1) { print("$riga[$ii]\n"); } } ?>